{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 21点游戏的蒙特卡洛学习评估玩家策略"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 示例：二十一点游戏 Blackjack Example\n",
    "本章的编程实践将使用MC学习来评估二十一点游戏中一个玩家的策略。为了完成这个任务，我们需要先了解二十一点游戏的规则，并构建一个游戏场景让庄家和玩家在一个给定的策略下进行博弈生成对局数据。这里的对局数据在强化学习看来就是一个个完整的状态序列组成的集合。然后我们使用本章介绍的蒙特卡罗算法来评估其中玩家的策略。本节的难点不在于蒙特卡罗学习算法的实现，而是对游戏场景的实现并生成让蒙特卡罗学算法学习的多个状态序列。\n",
    "\n",
    "**二十一点游戏规则**\n",
    "\n",
    "二十一点游戏是一个比较经典的对弈游戏，其规则也有各种不同的版本，为了简化，本文仅介绍由一个庄家(dealer)和一个玩家(player)共2位游戏者参与的一个比较基本的规则版本。游戏使用一副除大小王以外的52张扑克牌，游戏者的目标是使手中的牌的点数之和不超过21点且尽量大。其中2-10的数字牌点数就是牌面的数字，J,Q,K三类牌均记为10点，A既可以记为1也可以记为11，由游戏者根据目标自己决定。牌的花色对于计算点数没有影响。\n",
    "\n",
    "开局时，庄家将依次连续发2张牌给玩家和庄家，其中庄家的第一张牌是明牌，其牌面信息对玩家是开放的，庄家的第二张牌信息不对玩家开放。随后玩家可以根据自己手中牌的点数决定是否继续要牌(twist)或停止要牌(stick),玩家可以连续继续要牌，但一旦手中牌点数超过21点则不应继续要牌。当玩家停止要牌后，庄家可以决定是否继续要牌。如果庄家停止要牌，对局结束，双方亮牌计算输赢。\n",
    "\n",
    "计算输赢的规则如下：如果双方点数均超过21点或双方点数相同，则和局；一方21点另一方不是21点，则点数为21点的游戏者赢；如果双方点数均不到21点，则点数离21点近的玩家赢。\n",
    "\n",
    "**将二十一点游戏建模为强化学习问题**\n",
    "\n",
    "为了讲解基于完整状态序列的蒙特卡洛学习算法，我们把二十一点游戏建模成强化学习问题，设定由下面三个参数来集体描述一个状态：庄家的明牌(第一张牌)点数；玩家手中所有牌点数之和；玩家手中是否还有“可用(useable)”的A(ace)。前两个比较好理解，第三个参数是与玩家策略相关的，玩家是否有A这个比较好理解，可用的A指的是玩家手中的A按照目标最大化原则是否没有被计作1点，如果这个A没有被记为1点而是计为了11点，则成这个A为可用的A，否则认为没有可用的A，当然如果玩家手中没有A，那么也被认为是没有可用的A。例如玩家手中的牌为“A,3,6”，那么此时根据目标最大化原则，A将被计为11点，总点数为20点，此时玩家手中的A称为可用的A。加入玩家手中的牌为“A，5,7”，那么此时的A不能被计为11点只能按1计，相应总点数被计为13点，否则总点数将为23点，这时的A就不能称为可用的A。\n",
    "根据我们对状态的设定，我们使用由三个元素组成的元组来描述一个状态。例如使用(10,15, 0)表示的状态是庄家的明牌是10，玩家手中的牌加起来点数是15，并且玩家手中没有可用的A，(A,17,1)表述的状态是庄家第一张牌为A，玩家手中牌总点数为17,玩家手中有可用的A。这样的状态设定不考虑玩家手中的具体牌面信息，也不记录庄家除第一张牌外的其它牌信息。所有可能的状态构成了状态空间。\n",
    "\n",
    "该问题的行为空间比较简单，玩家只有两种选择：“继续要牌”或“停止要牌”。\n",
    "\n",
    "该问题中的状态如何转换取决于游戏者的行为以及后续发给游戏者的牌，状态间的转移概率很难计算。\n",
    "\n",
    "可以设定奖励如下：当棋局未结束时，任何状态对应的奖励为0；当棋局结束时，如果玩家赢得对局，奖励值为1，玩家输掉对局，奖励值为-1，和局是奖励为0。\n",
    "\n",
    "本问题中衰减因子$\\gamma=1$。\n",
    "\n",
    "游戏者在选择行为时都会遵循一个策略。在本例中，庄家遵循的策略是只要其手中的牌点数达到或超过17点就停止要牌。我们设定玩家遵循的策略是只要手中的牌点数不到20点就会继续要牌，点数达到或超过20点就停止要牌。\n",
    "\n",
    "我们的任务是评估玩家的这个策略，即计算在该策略下的状态价值函数，也就是计算状态空间中的每一个状态其对应的价值。\n",
    "\n",
    "**游戏场景的搭建**\n",
    "\n",
    "首先来搭建这个游戏场景，实现生成对局数据的功能，我们要实现的功能包括：统计游戏者手中牌的总点数、判断当前牌局信息对应的奖励、实现庄家与玩家的策略、模拟对局的过程生成对局数据等。为了能尽可能生成较符合实际的对局数据，我们将循环使用一副牌，对局过程中发牌、洗牌、收集已使用牌等过程都将得到较为真实的模拟。\n",
    "\n",
    "先讲解如何判断游戏者手中牌的总点数。由于不涉及牌的花色，我们使用长度为1的字符串来记录单张牌的牌面信息。为了判断游戏者手中多张牌的总点数，我们编写了如下两个方法："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 蒙特卡罗预测"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import shuffle\n",
    "from queue import Queue\n",
    "from tqdm import tqdm\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from utils import str_key, set_dict, get_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Gamer():\n",
    "    '''游戏者\n",
    "    '''\n",
    "    def __init__(self, name = \"\", A = None, display = False):\n",
    "        self.name = name\n",
    "        self.cards = [] # 手中的牌\n",
    "        self.display = display # 是否显示对局文字信息\n",
    "        self.policy = None # 策略\n",
    "        self.learning_method = None # 学习方法\n",
    "        self.A = A # 行为空间\n",
    "        \n",
    "    def __str__(self):\n",
    "        return self.name\n",
    "    \n",
    "    def _value_of(self, card):\n",
    "        '''根据牌的字符判断牌的数值大小，A被输出为1, JQK均为10，其余按牌字符对应的数字取值\n",
    "        Args:\n",
    "            card: 牌面信息 str\n",
    "        Return:\n",
    "            牌的大小数值 int, A 返回 1\n",
    "        '''\n",
    "        try:\n",
    "            v = int(card)\n",
    "        except:\n",
    "            if card == 'A':\n",
    "                v = 1\n",
    "            elif card in ['J','Q','K']:\n",
    "                v = 10\n",
    "            else:\n",
    "                v = 0\n",
    "        finally:\n",
    "            return v\n",
    "    \n",
    "    def get_points(self):\n",
    "        '''统计一手牌分值，如果使用了A的1点，同时返回True\n",
    "        Args:\n",
    "            cards 庄家或玩家手中的牌 list ['A','10','3']\n",
    "        Return\n",
    "            tuple (返回牌总点数,是否使用了可复用Ace) \n",
    "            例如['A','10','3'] 返回 (14, False)\n",
    "               ['A','10'] 返回 （21, True)\n",
    "        '''\n",
    "        num_of_useable_ace = 0 # 默认没有拿到Ace\n",
    "        total_point = 0 # 总值\n",
    "        cards = self.cards\n",
    "        if cards is None:\n",
    "            return 0, False\n",
    "        for card in cards:\n",
    "            v = self._value_of(card)\n",
    "            if v == 1:\n",
    "                num_of_useable_ace += 1\n",
    "                v = 11\n",
    "            total_point += v\n",
    "        while total_point > 21 and num_of_useable_ace > 0:\n",
    "            total_point -= 10\n",
    "            num_of_useable_ace -= 1\n",
    "        return total_point, bool(num_of_useable_ace)\n",
    "    \n",
    "    def receive(self, cards = []): # 玩家获得一张或多张牌\n",
    "        cards = list(cards)\n",
    "        for card in cards:\n",
    "            self.cards.append(card)\n",
    "    \n",
    "    def discharge_cards(self): # 玩家把手中的牌清空，扔牌\n",
    "        '''扔牌\n",
    "        '''\n",
    "        self.cards.clear()\n",
    "    \n",
    "    \n",
    "    def cards_info(self): # 玩家手中牌的信息\n",
    "        '''\n",
    "        显示牌面具体信息\n",
    "        '''\n",
    "        self._info(\"{}{}现在的牌:{}\\n\".format(self.role, self,self.cards))\n",
    "    \n",
    "    def _info(self, msg):\n",
    "        if self.display:\n",
    "            print(msg, end=\"\")\n",
    "        \n",
    "        \n",
    "class Dealer(Gamer):\n",
    "    def __init__(self, name = \"\", A = None, display = False):\n",
    "        super(Dealer,self).__init__(name, A, display)\n",
    "        self.role = \"庄家\"\n",
    "        self.policy = self.dealer_policy\n",
    "    \n",
    "    def first_card_value(self):\n",
    "        if self.cards is None or len(self.cards) == 0:\n",
    "            return 0\n",
    "        return self._value_of(self.cards[0])\n",
    "    \n",
    "    def dealer_policy(self, Dealer = None):\n",
    "        action = \"\"\n",
    "        dealer_points, _ = self.get_points()\n",
    "        if dealer_points >= 17:\n",
    "            action = self.A[1] # \"停止要牌\"\n",
    "        else:\n",
    "            action = self.A[0]\n",
    "        return action\n",
    "        \n",
    "\n",
    "class Player(Gamer):\n",
    "    def __init__(self, name = \"\", A = None, display = False):\n",
    "        super(Player, self).__init__(name, A, display)\n",
    "        self.policy = self.naive_policy\n",
    "        self.role = \"玩家\" # “庄家”还是“玩家”，庄家是特殊的玩家\n",
    "    \n",
    "    def get_state(self, dealer):\n",
    "        dealer_first_card_value = dealer.first_card_value()\n",
    "        player_points, useable_ace = self.get_points()\n",
    "        return dealer_first_card_value, player_points, useable_ace\n",
    "        \n",
    "    def get_state_name(self, dealer):\n",
    "        return str_key(self.get_state(dealer))\n",
    "\n",
    "    def naive_policy(self, dealer=None):\n",
    "        player_points, _ = self.get_points()\n",
    "        if player_points < 20:\n",
    "            action = self.A[0]\n",
    "        else:\n",
    "            action = self.A[1]        \n",
    "        return action  \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Arena():\n",
    "    '''负责游戏管理\n",
    "    '''\n",
    "    def __init__(self, display = None, A = None):\n",
    "        self.cards = ['A','2','3','4','5','6','7','8','9','10','J','Q',\"K\"]*4\n",
    "        self.card_q = Queue(maxsize = 52) # 洗好的牌\n",
    "        self.cards_in_pool = [] # 已经用过的公开的牌  \n",
    "        self.display = display\n",
    "        self.episodes = [] # 产生的对局信息列表\n",
    "        self.load_cards(self.cards)# 把初始状态的52张牌装入发牌器\n",
    "        self.A = A # 获得行为空间\n",
    "\n",
    "    def load_cards(self, cards):\n",
    "        '''把收集的牌洗一洗，重新装到发牌器中\n",
    "        Args:\n",
    "            cards 要装入发牌器的多张牌 list\n",
    "        Return:\n",
    "            None\n",
    "        '''\n",
    "        shuffle(cards) # 洗牌\n",
    "        for card in cards:# deque数据结构只能一个一个添加\n",
    "            self.card_q.put(card)\n",
    "        cards.clear() # 原来的牌清空\n",
    "        return\n",
    "       \n",
    "    def reward_of(self, dealer, player):\n",
    "        '''判断玩家奖励值，附带玩家、庄家的牌点信息\n",
    "        '''\n",
    "        dealer_points, _ = dealer.get_points()\n",
    "        player_points, useable_ace = player.get_points()\n",
    "        if player_points > 21:\n",
    "            reward = -1\n",
    "        else:\n",
    "            if player_points > dealer_points or dealer_points > 21:\n",
    "                reward = 1\n",
    "            elif player_points == dealer_points:\n",
    "                reward = 0\n",
    "            else:\n",
    "                reward = -1\n",
    "        return reward, player_points, dealer_points, useable_ace\n",
    "    \n",
    "    def serve_card_to(self, player, n = 1):\n",
    "        '''给庄家或玩家发牌，如果牌不够则将公开牌池的牌洗一洗重新发牌\n",
    "        Args:\n",
    "            player 一个庄家或玩家 \n",
    "            n 一次连续发牌的数量\n",
    "        Return:\n",
    "            None\n",
    "        '''\n",
    "        cards = []  #将要发出的牌\n",
    "        for _ in range(n):\n",
    "            # 要考虑发牌器没有牌的情况\n",
    "            if self.card_q.empty():\n",
    "                self._info(\"\\n发牌器没牌了，整理废牌，重新洗牌;\")\n",
    "                shuffle(self.cards_in_pool)\n",
    "                self._info(\"一共整理了{}张已用牌，重新放入发牌器\\n\".format(len(self.cards_in_pool)))\n",
    "                assert(len(self.cards_in_pool) > 20) # 确保有足够的牌，将该数值设置成40左右时，如果玩家\n",
    "                # 即使爆点了也持续的叫牌，会导致玩家手中牌变多而发牌器和已使用的牌都很少，需避免这种情况。\n",
    "                self.load_cards(self.cards_in_pool) # 将收集来的用过的牌洗好送入发牌器重新使用\n",
    "            cards.append(self.card_q.get()) # 从发牌器发出一章牌\n",
    "        self._info(\"发了{}张牌({})给{}{};\".format(n, cards, player.role, player))\n",
    "        #self._info(msg)\n",
    "        player.receive(cards) # 牌已发给某一玩家\n",
    "        player.cards_info()\n",
    "\n",
    "        \n",
    "    def _info(self, message):\n",
    "        if self.display:\n",
    "            print(message, end=\"\")\n",
    "        \n",
    "    def recycle_cards(self, *players):\n",
    "        '''回收玩家手中的牌到公开使用过的牌池中\n",
    "        '''\n",
    "        if len(players) == 0:\n",
    "            return\n",
    "        for player in players:\n",
    "            for card in player.cards:\n",
    "                self.cards_in_pool.append(card)\n",
    "            player.discharge_cards() # 玩家手中不再留有这些牌\n",
    "                \n",
    "    def play_game(self, dealer, player):\n",
    "        '''玩一局21点，生成一个状态序列以及最终奖励（中间奖励为0）\n",
    "        Args：\n",
    "            dealer/player 庄家和玩家手中的牌 list\n",
    "        Returns:\n",
    "            tuple：episode, reward\n",
    "        '''\n",
    "        #self.collect_player_cards()\n",
    "        self._info(\"========= 开始新一局 =========\\n\")\n",
    "        self.serve_card_to(player, n=2) # 发两张牌给玩家\n",
    "        self.serve_card_to(dealer, n=2) # 发两张牌给庄家\n",
    "        episode = [] # 记录一个对局信息\n",
    "        if player.policy is None:\n",
    "            self._info(\"玩家需要一个策略\")\n",
    "            return\n",
    "        if dealer.policy is None:\n",
    "            self._info(\"庄家需要一个策略\")\n",
    "            return\n",
    "        while True:\n",
    "            action = player.policy(dealer)\n",
    "            # 玩家的策略产生一个行为\n",
    "            self._info(\"{}{}选择:{};\".format(player.role, player, action))\n",
    "            episode.append((player.get_state_name(dealer), action)) # 记录一个(s,a)\n",
    "            if action == self.A[0]: # 继续叫牌\n",
    "                self.serve_card_to(player) # 发一张牌给玩家\n",
    "            else: # 停止叫牌\n",
    "                break\n",
    "        # 玩家停止叫牌后要计算下玩家手中的点数，玩家如果爆了，庄家就不用继续了        \n",
    "        reward, player_points, dealer_points, useable_ace = self.reward_of(dealer, player)\n",
    "        \n",
    "        if player_points > 21:\n",
    "            self._info(\"玩家爆点{}输了，得分:{}\\n\".format(player_points, reward))\n",
    "            self.recycle_cards(player, dealer)\n",
    "            self.episodes.append((episode, reward)) # 预测的时候需要形成episode list后同一学习V\n",
    "            # 在蒙特卡洛控制的时候，可以不需要episodes list,生成一个episode学习一个，下同\n",
    "            self._info(\"========= 本局结束 ==========\\n\")\n",
    "            return episode, reward\n",
    "        # 玩家并没有超过21点\n",
    "        self._info(\"\\n\")\n",
    "        while True:\n",
    "            action = dealer.policy() # 庄家从其策略中获取一个行为\n",
    "            self._info(\"{}{}选择:{};\".format(dealer.role, dealer, action))\n",
    "            if action == self.A[0]: # 庄家\"继续要牌\":\n",
    "                self.serve_card_to(dealer)\n",
    "                # 停止要牌是针对玩家来说的，episode不记录庄家动作\n",
    "                # 在状态只记录庄家第一章牌信息时，可不重复记录(s,a)，因为此时玩家不再叫牌，(s,a)均相同\n",
    "                # episode.append((get_state_name(dealer, player), self.A[1]))\n",
    "            else:\n",
    "                break\n",
    "        # 双方均停止叫牌了    \n",
    "        self._info(\"\\n双方均了停止叫牌;\\n\")\n",
    "        reward, player_points, dealer_points, useable_ace = self.reward_of(dealer, player)\n",
    "        player.cards_info() \n",
    "        dealer.cards_info()\n",
    "        if reward == +1:\n",
    "            self._info(\"玩家赢了!\")\n",
    "        elif reward == -1:\n",
    "            self._info(\"玩家输了!\")\n",
    "        else:\n",
    "            self._info(\"双方和局!\")\n",
    "        self._info(\"玩家{}点,庄家{}点\\n\".format(player_points, dealer_points))\n",
    "        \n",
    "        self._info(\"========= 本局结束 ==========\\n\")\n",
    "        self.recycle_cards(player, dealer) # 回收玩家和庄家手中的牌至公开牌池\n",
    "        self.episodes.append((episode, reward)) # 将刚才产生的完整对局添加值状态序列列表，蒙特卡洛控制不需要\n",
    "        return episode, reward\n",
    "    \n",
    "    def play_games(self, dealer, player, num=2, show_statistic = True):\n",
    "        '''一次性玩多局游戏\n",
    "        '''\n",
    "        results = [0, 0, 0]# 玩家负、和、胜局数\n",
    "        self.episodes.clear()\n",
    "        for i in tqdm(range(num)):\n",
    "            episode, reward = self.play_game(dealer, player)\n",
    "            results[1+reward] += 1\n",
    "            if player.learning_method is not None:\n",
    "                player.learning_method(episode ,reward)\n",
    "        if show_statistic:\n",
    "            print(\"共玩了{}局，玩家赢{}局，和{}局，输{}局，胜率：{:.2f},不输率:{:.2f}\"\\\n",
    "              .format(num, results[2],results[1],results[0],results[2]/num,(results[2]+results[1])/num))\n",
    "        pass\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=[\"继续叫牌\",\"停止叫牌\"]\n",
    "display = False\n",
    "# 创建一个玩家一个庄家，玩家使用原始策略，庄家使用其固定的策略\n",
    "player = Player(A = A, display = display)\n",
    "dealer = Dealer(A = A, display = display)\n",
    "# 创建一个场景\n",
    "arena = Arena(A = A, display=display)\n",
    "# 生成num个完整的对局"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 200000/200000 [00:19<00:00, 10142.90it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "共玩了200000局，玩家赢58785局，和11180局，输130035局，胜率：0.29,不输率:0.35\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "arena.play_games(dealer, player, num=200000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 统计个状态的价值，衰减因子为1，中间状态的即时奖励为0，递增式蒙特卡洛评估\n",
    "def policy_evaluate(episodes, V, Ns):\n",
    "    for episode, r in episodes:\n",
    "        for s, a in episode:\n",
    "            ns = get_dict(Ns, s)\n",
    "            v = get_dict(V, s)\n",
    "            set_dict(Ns, ns+1, s)\n",
    "            set_dict(V, v+(r-v)/(ns+1), s)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "V = {} # 状态价值字典\n",
    "Ns = {} # 状态被访问的次数节点\n",
    "policy_evaluate(arena.episodes, V, Ns) # 学习V值\n",
    "#print(V)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_value(value_dict, useable_ace = True, is_q_dict = False, A = None):\n",
    "    # 定义figure\n",
    "    fig = plt.figure()\n",
    "    # 将figure变为3d\n",
    "    ax = Axes3D(fig)\n",
    "    # 定义x, y\n",
    "    x = np.arange(1, 11, 1) # 庄家第一张牌\n",
    "    y = np.arange(12, 22, 1) # 玩家总分数\n",
    "    # 生成网格数据\n",
    "    X, Y = np.meshgrid(x, y)\n",
    "    # 从V字典检索Z轴的高度\n",
    "    row, col = X.shape\n",
    "    Z = np.zeros((row,col))\n",
    "    if is_q_dict:\n",
    "        n = len(A)\n",
    "    for i in range(row):\n",
    "        for j in range(col):\n",
    "            state_name = str(X[i,j])+\"_\"+str(Y[i,j])+\"_\"+str(useable_ace)\n",
    "            if not is_q_dict:\n",
    "                Z[i,j] = get_dict(value_dict, state_name)\n",
    "            else:\n",
    "                assert(A is not None)\n",
    "                for a in A:\n",
    "                    new_state_name = state_name + \"_\" + str(a)\n",
    "                    q = get_dict(value_dict, new_state_name)\n",
    "                    if q >= Z[i,j]:\n",
    "                        Z[i,j] = q\n",
    "    # 绘制3D曲面\n",
    "    ax.plot_surface(X, Y, Z, rstride = 1, cstride = 1, color=\"lightgray\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcUAAAE1CAYAAACWU/udAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvFvnyVgAAIABJREFUeJzsnXmMZFd1/7+v6tVeXd1dvc7W3TO9zXSPl/GsNsRy2JyYyCGI4CRgcAIoQiQKCiFYQkRWBMog8iMKIZAoGA3ICcaQKEbBkGAbE0Q8HmyPDWN7umvpfV9q31+99/tj5j5eVdfy3qt7e6qn7kcaeTxT815VddX93nPuOecrKIoCDofD4XA4gOVGPwEOh8PhcJoFLoocDofD4VyHiyKHw+FwONfhosjhcDgcznW4KHI4HA6Hcx0uihwOh8PhXIeLIofD4XA41+GiyOFwOBzOdbgocjgcDodzHdHg4/n4Gw6Hw+HsRQQ9D+KRIofD4XA41+GiyOFwOBzOdbgocjgcDodzHS6KHA6Hw+Fch4sih8PhcDjX4aLI4XA4HM51uChyOBwOh3MdLoocDofD4VyHiyKHw+FwONfhosjhcDgcznW4KHI4HA6Hcx0uihwOh8PhXIeLIofD4XA41+GiyOFwOBzOdbgocjgcDodzHS6KHA6Hw+Fch4sih8PhcDjXEW/0E+BwdhNFUVAsFiEIAiwWCwRBlxk3h8NpEbgocloCIoaSJCGXy0FRFACAxWKBxWKBKIqwWq3q/3Ox5HBaE4EsDjox9GAO50ajFUNFUSAIAgqFArSfe0VRUP49sFgssFqt6i8ulhzOnkfXl5eLIuempJIYEkHL5/Pqn1X7t+S/XCw5nJsGLoqc1kNRFEiShGKxuEMMCfVEsda1yX+5WHI4ew4uipzWgYihJEkAUFEMCWZFsda9yX+5WHI4TQsXRc7NjxExJBQKBciyzFyYtGKpvV8ul0M+n4ff7+diyeHsHrq+XLz6lLMnMSOGuw15PqT9g5DNZrG5uYm2tjbk8/mS580jSw7nxsJFkbOnkGVZLaABmlMM60Ges9VqLflzkn4tFAoVxVIURVU0uVhyOGzgosjZE9wMYliPaq+JiGWls9DyqNJqtd6U7w2Hs1twUeQ0NbIsIxqNAgBcLtdNs+AbOcuvJZZks1BLLIlg3izvHYfDEi6KnKZElmW1tWJtbQ1OpxMej+dGPy0q0BImLpYcDn24KHKaBu2ZmizLAH5VpGKwSrql0SOW5XCx5HCuwUWRc8OpJoZkQbZYLOqfc8yjVyyTySRSqRT6+vpUkSRFPlwsOTc7XBQ5NwyyGEuSVFEMCbRFkRSs2O12atfcy5S/55IkIZPJqO97sVhEPp8veTwp6uFiybnZ4KLI2XXKxZAsptUWVEEQqIhiOp1GOBxGPB6HxWKBJEmw2+3weDzweDzwer3weDw7WiVoIwhCU6eDtePx6kWWXCw5NxtcFDm7hlExJDR6pphOpxEKhZBKpTA8PIzx8XFVZAuFgpouXF5eRiqVQrFYVAt7tL+0Dfg3M/VG4JkVy0r2XFwsOc0GF0UOc6o5VuhdEM1GiqlUCqFQCJlMBkeOHEF3dzcEQSjpdbTb7fD7/fD7/SXPN5fLIZVKIZlMYnt7G+l0GrIsw+VyqRGlx+OBy+VqGbGsRz2xzOVyOx5faXoPfz85NxIuihxmVBJDMwue0TPFZDKJcDiMTCaD4eFhdHV17Visa0VDgiDA6XTC6XSiq6ur5N9kMhlVLNfX15HJZAAAbre7JAXrdDr3bBREc1g6UFksSeSvHcigfXy1oQQcDmu4KHKoQ0sMCXrTp8lkEqFQCLlcDsPDw/D7/dQXd7fbDbfbjZ6eHvXPZVlGOp1GKpVCPB7H+vo6ZmdnkUgkIIoi7HY7nE4nXC4XnE4nACCTycDhcKi/7HY7HA4HbDYbtedrFtqiWAntXNjyewO1xVJ7XsnFkkMbLoocatAWQ0K99GkikUAoFEKhUMCRI0dKorvdwGKxqBFiNBrF9vY2ksmk2mZSKBSQSqV2/LulpaWK1yICqf2vz+dDe3s7enp6IIpsv7a7IYrV0CuWMzMz6O3thdvtLinu4XNhOY3CRZHTMJWMfWmeC1VLnyYSCQSDQUiSpEaGN4pCoYDNzU3k83lsbW2ZrpaVZRnZbBbZbFb9M7LI5/N5WCwWdHd3o7+/H319fejq6mqJM7hysczn82p6FcCOzRh5LBdLjlG4KHJMQ8RwZmYGhw4doi6GhPL0aTweRygUQrFYxPDwMDo7O6nf0wiJRAKRSEQtKFlYWKB6fbvdjnQ6DeCaaK6vr2N9fR0AYLPZ0NPTg/7+fvT396Ojo6Ph+93ISFEv2uploH5kqX1N3J6LUwsuihzDlHsZLi8vq6LIApI+jcViCIVCUBQFR44cMS2GtJ5nsVjE1taWWmwDALFYDIVCgcr1gfoCVSgUsLy8jOXlZQCA0+lEX1+fGkl6vV7q92wGZFmuuQGrJ5aSJO34OXGx5ABcFDkGqGbsS9KbrNJ4qVRKTU0ODw9TiYYaJZPJYHNzsyRNqigK9SjR7/dja2tL9+Oz2Szm5uYwNzcH4FpV7L59+1SRJIU+ex1FUUx93rhYcurBRZFTl3ou96xmk0ajUYRCIciyDK/Xi5MnT1K/h1EURUEkEkEikdjxd6lUqmJBTSM0+r6SwQWhUAgA1MrZ/fv3w+fzqRWxWoHZK5Ei7cpi7X8JXCxbDy6KnKroNfa1Wq1URTESiSAUCsFisWB0dBQ2mw1Xr16ldn2z5PN5bG5uVk2PkhQmLbxeLyKRCNVrptNpzM3NYXl5uaSZXhRFOBwOuFwuAIDD4cDW1pbar6n91QwzY1lmJrRwsWw9uChydqD1MgTqu9xbLJaKdkRGiUQiCAaDEEURY2Nj8Pl8AK6lBG+kS4aiKGoxTTVyuZyhNKceHA4H1esROjs7dzxXkgnQRrqVWkaAaz/vcqFsa2uD0+mE1+tV21NYitaNjmbriSWpRo5EIhgaGgLAxXKvwEWRo2JUDAmNpk+3t7cRCoVgs9lw9OhRtLW1Ub1+I0iShK2trZIWiUqsra1Rva/dbsf29jbVaxIa3cCQYQWkIhYA+vv7S4SWDDogIqkVS6/X2/CQArNniqwh3xer1aoKJPk96VvN5/M7jh+4WDYPXBRbnHpehnowI1qKoqhiaLfbK4qh9vo3wlUinU7r6jmUJIl66tTn86ltFzTp6OigLraiKO6IPBVFUc9YK20YHA7HDsEkv26WYiBtirfWXNhaYqntsSTTe7hYsoWLYotCQwwJRs4UFUXB1tYWwuEwHA4HJiYm6rYN0LKOAq71OAaDQWQymR2WUQ6HQ71XJBJBMpnUdc3NzU2qoi0IAmKxGLXraWGxueju7jacOs7lclVTzqIowuPxwOfzQZKkHf2IgiBge3sbFy9eLPmz8kHz5f9PIrHe3l74/X7mkWaxWKxrQ1ZPLIn3p/Yx1ebCcrGkAxfFFoOmGBL0RIpEDEOhEFwuly4xNHL9epDpN8ViEUeOHIHT6VSHe0ciESwuLiKXy8HhcMDn8+leMGVZxuLiYkPPrRy/34+NjQ2q1wSA9vZ26oU7DoeD+jUlSYLValXbSqpRqQK4Fu3t7WpEL4oiuru70dPTg97eXvT29sLj8Zh+zpXQI4rV0GPPVUssiWBysTQOF8UWwayXoR5qFdooioLNzU2Ew2G43W4cP37c8OLTyHPUzkUdGRlBZ2cnZFlGPp9HW1tbSco2FoshGo0aun40GqXarA+g7vmlWVgsjn6/H5ubm9SvqzdK14vX68XKyor6/5IkYXV1Faurq+qfeTyeEpHs7u5uaM6sLMvU59RysWQPF8WbHJZiSKgUySmKgo2NDYTDYXi9Xtxyyy1wu93U7lmPZDKJYDBYIoa1KBaLhgVRlmWEw+FGnuYOWERzwLUzStpniTabzfB7pgefz0f9utlstm7qmJyBzs7OArgmQH6/XxXJ3t5etLe3675nsVhkVkFcjh6xLIeIpNZ1hIslF8WbFuJYsba2ploosfrAa88Uy8Xw1ltv3XUxJPZRIyMjuoeEm4nOUqkU9SiR1YJkNo1Xi+7ubupRoiiKJVWtNOjo6KjaXlILkvLf2trCG2+8AeBaulgbTfb09FQVPlmWmbzvRtAjlolEAouLixgeHgbAxZKL4k1GuX3T9PQ07rrrLqb3JOnTtbU1hMNh+Hw+3HbbbWoj+G6QSqUQCoWQzWZVY2EjlLvC64F2xanb7WbShuH1eqn3UFqtVsTjcarXBK4JGM2qW5vNRvV6uVwOi4uL6jlyT08PIpGIau3l8/nU36fT6Rs+rL4aWpEj6wVpHSFimc/nSx6vtei6mcWSi+JNAisvQz33TSQS2NjYQG9vL26//fYbIoaZTEaNDM18SY1GitlslklrAwtYTKDp6elhMqyA9jVlWaYezRO8Xi+Wl5chyzJSqVTJmSXBZrOVCKZWONva2m54JAlcE0Xy2dMTWRKxXFhYwJe//GX88z//864+X9ZwUdzj6BFDFiOxFEXB6uoqZmZmYLPZsH//foyNjVG9Ry3ITM90Oq1GhmZ3rGYWTtrN+qIoMom83G43daGxWCzUZ7wC1wpdtI4jjeLz+SoKFS2IUNSiUCioKdhyBEGA1+utKJjd3d27NpxAkqS6G7JKYhmNRqn+vJoFLop7FL3GvuS8j9YXTFEUrKysYHZ2Fp2dnbjjjjsQi8WoVwtWI51OIxwOI5lMYnh4GN3d3abEUPtvjKZOC4UC9cWWdtqQ4HK5qP9senp6qEfJtFO8FouFySaD0NPT03ArDsmylLeWkErZU6dO4fTp04aKe8xAUqdGicVi6ijGmwkuinuMSo4VtQTParWWpEfMIssyVldXMTs7C7/fj5MnT6oFBolEgvkYNlmWceXKFVUMJycnqZ1lGE2dbm1tUW/WZ7GAu1wu6oUwgiAwaRkRRZHqe+rz+UwV1+jBbrdTP08m2Gw2hEIh5PN5PP3003j22WcxNjaGM2fO4OjRo0yiR7PrQzwebwobN9pwUdwj1LNvqgYRRbPIsoyVlRXMzc2hq6urRAwJtAaCVyKTySAcDiOTyWB0dJSqGBKMRIp7qVlflmXqE2xIYQlN2tvbqUaebrebadqUtiuMFovFUlLgIssyrl69iqtXr6K9vV2NHmmKkSRJplpHYrEY8yj2RsBFsckxK4YEs6IoyzKWl5cxNzeH7u5unDp1qmrBBouB3dlsFuFwGLFYDEeOHEEsFkNPTw91QZRl2ZAosmjWN1P5Wg+Hw8HkuuRzSAtyJk4TWZaZiRaNtGk1XC4XgsFg1b+PxWJ45plnSqLHY8eONRw9mo0UY7EYuru7G7p3M8JFsUlpVAwJRkVRK4Y9PT04ffp03epFmjvncjE8duwYBEHA7OwstajH7HmioihYWFig8hwILBrVAaCtrY16EURXVxf1NG9XVxfVFK/ZnkQ9eDyekgk4tNFrkaYoCqampjA1NQWfz6dGj2bbP/QU2lQikUiovY03E1wUmwy9xr560SuKsixjaWkJ8/Pz6O3t1SWGBBqRYjabxczMDKLRKA4fPqyKIYEM6qZdwm5EFJPJJPXGchYl+SxaGwD6UaIgCFSrWCu5ddCCWFXRfg8IFoul7qzXSsTjcTz77LP48Y9/jNHRUTV6NPK5MiuKsViMnyly2GHWy7Ae9USRnJEtLCygt7cXZ86cMex118iZYi6XQzgcRiQSweHDh3H06NGKr5uVfZTR1KnNZqOWPnW5XEya9X0+H/WWEZ/PR31D0NXVRbXi1u12M3MX6e3tZZY2VRSl4aieDOqYnp5GW1sbTp48iTNnzuia6GR2cHk8Hudnihz6sBJDQrXUZrFYVCdz9PX1mRJDgplIMZfLYWZmBtvb2zXFkEDLPqpYLGJhYQEbGxvweDy6X7MoivD7/ejs7FSdRrQNzSS6J754+XweuVyupGiiHI/HQ73fz2azMYmWiKsILURRpJo2bmtrY1Zc43K5qG8ytPh8Prz++uvUrpdIJPDcc8/hJz/5CUZGRnDmzBlMTExUFT4eKZbCRfEGQRrGadk3VaM8itOKYX9/P86ePdtwu4YRUczn85iZmcHW1haGhoYwPj6u63U3mqLVRsT9/f0YHR1FMpnUvdAnk0k1Ui336KsnrKQKlAhooVBAPB6HKIpoa2tDKpWidibb0dFBfQFnMaTc5/NRPUtk2UROMztQjsViYRqBBgIBBAIB3HLLLXjf+95X8XFm+xR5SwanYbRehq+//jpGR0chiiLT2YEkfUoipMXFRezfv5+KGGrvUW9RLxfDsbExQ69bEART6VNt4RBJD4uiiHw+j0KhoGsxzWQyyGQypselkepAIqBOpxMejweKosDv95dEnZIkIZfLIZvNIpVKIZPJ6H7doigyScc6nU6qqVPaZ38si2u6u7uZXRu4lvI1c5ZoFIvFgsuXL5eYans8HrU/1EwFK0+fckxTydg3nU6rVk4sEQQB6+vrmJ+fx4EDB3Du3DnqMzZrnSnm83nMzs5iY2MDQ0NDGB0dNfUFNBopaifvdHV1lRQOEZHRc54oCALy+TyT+aHae5AhDKIowul0qosN+eyQCDOXy6nmyOXPv7Ozk3qU6PV6mzpKdDgczFKbTqeTSf8owWazUbceq8Z9990Hl8ul2mOtrKwglUqhWCwik8kgGAyqgul2u3VFjpIkMf1e3Ci4KDKk3MsQ+NUCKIqi6aZZPUiShIWFBczNzcHj8TARQ0IlYS8UCpidncX6+joGBwdx5513NtRPpbfQRlEUrK+vIxQKobOzs+KwAfI4vUU2kiTB5XLVPB80it7oTyuYNpsNbrdbLb0vH9IsSRK6u7vVyJZGSpb2+DWPx2PqeqIoQhRFOBwOiKIIu92OtrY22Gw2pNNpZLNZpNNpJJNJJBIJKkVZDoeDWeEOcC1zwKKXtJwDBw6omyy73V7SuqEoCi5duoTOzk6kUiksLi6q6XyXy6VGlB6PB263W/0Osyh6axa4KDJAj7GvKIpMpsBIkoT5+XmsrKzgwIEDOHbsGKLRKDNBLIe2GBLqRYqKomBzcxPBYBA+nw933HEHnE5nzedZTzSsVqsaKezWcGYjCIKget+5XC7IslwimEBpiw+JNEm0Wc94l4WVVfk4N0EQ4HQ64XQ64XA4YLfbYbPZIIoirFZrXR9QSZLgdrvhdrvVSktyhkuKntLpNNLpNOLxuO6NDeu0ab1GfZpMTExU/TuSOu3q6iqxW1MURU3hJ5NJbG5uqin073znO6rNVCgUwuHDhw2dSf7whz/En/3Zn6FYLOLDH/4wHn744ZK/n5+fxwc/+EFEo1EUi0WcP38e9913n8FXbR4uihSp5FhR7QtttVqp9jxJkoS5uTmsrq7i4MGDOHfuHKxWKyKRCLMRbFoURUEwGMTa2hoGBgaoiSGhWvWpoijY3t5GMBiE2+3GbbfdpsvUWM8OPZ/PM9sRm634qwY5JyVoC4GsVmvFNFd5Ba0kScjn82pVqM/nQyKRUCNV7ee5/P/Lf5HnoP1FRK63t1eX4OnB7XbvmMWqPcN1Op0lQ6vJZrVQKJREl9pCKofDQX1mbDm5XI75vGBCLVGsNs1GEAS4XC64XK6SqTWyLMPpdOLSpUv47//+bzz88MMIh8Ow2Wz40pe+hLNnz9Z8LsViER/72Mfwox/9CAcPHsTp06dx//33lzzHz372s3jve9+Lj370o3j99ddx3333YXZ21vgLNwkXRQoYEUMCSZ82SqFQwNzcHNbW1krEkNDo7NN6EDFOpVKw2+3UxZBQKX0aiUQQCATgcDhw/PhxeDwe3derN9SaZSM4QL9p38x7Xn6W6XA44PF41GjTarVSrS70er3Uh4kb/Q5ZLBbY7XbY7XZ4PB41OtKe25KjB1apTa/XizfeeIPJtcvx+/3Yt29f1b83WnlqsVhwyy23oLu7G0899RS++93vAtA/VP/SpUsYGRnBkSNHAAC/93u/hyeffLJEFLUD8mOxGPbv36/7+dGAi2IDNGLs26hYadOUhw4dqipGrERRG5keOnQIHo8HAwMD1O9D0EaKsVgMgUAAVqsVx44dQ1tbm+Hr1Vvwyu18mv0MhcVGhMUEG5qQUYg0IOf85Lyyvb0dkiSpqcPV1VUq3yOS2dgtjh07VvPvG3HI0Fae1jqq0LK0tIRDhw6p/3/w4EG88MILJY955JFH8I53vAP/8A//gFQqhaefftrw82sELoomoOFybzZSzOfzmJubw/r6uq40JW1R1J5ZaiNTVr1WBGJsu7CwAEVRMDY2ZtrLLZ/P10xdiaK4owWh2UWRdgQmCMKupN0bwWazUS1+IpDvpSiK6OjoQEdHBw4fPoxUKoVoNIrV1VXTfZHt7e147bXXaD7dmtRKnQKNNe6z8lL81re+hYceegif+MQn8Pzzz+PBBx/ElStXdu1cn4uiAWiIIaH8DKge2tYGIwUstIZ1k5TS8vKy2tqhTbuQSI7FBzeZTGJ1dRWCIGBycrLhlF6tBU0QhIo7+WYXCNpOJbTPvAH6GwsWc2OrRbNWqxU+nw8+nw8HDx5EIpFANBrF9va27iHpgiAw3zxqcbvdOHz4cM3HmB3xZnaazYEDB0qG6i8uLuLAgQMlj3n00Ufxwx/+EABw5513IpvNYnNzE729vYbvZwYuijrQ63JvBL2LDml639zcNFXN2WikWCwWMT8/X1UMCWRRpimK6XQawWAQ2WwWnZ2d6OzspHLGVSuqEgSh4vQS2qJIO5VI64yawEJwaL+HLDZgeqrCLRYL2tvb0d7ejsHBQWSzWayvr6sCWU38PR4P5ufnqT/naoyPj9d9j8xGiman2Zw+fRqBQAAzMzM4cOAAHn/8cfzbv/1byWMGBgbwzDPP4KGHHsIbb7yBbDaLnp4ew/cyCxfFGhh1uTdCvUVMOxt0cHDQdNO72ZmhZALO0tIS9u/fX1UMCTQjlUwmg1AohFQqheHhYXR1dWFubo5apFEtUrRYLBWrDmm3s7A452120QaaP9oGzP1snE4nBgYGMDAwgGKxiHg8jpWVFUQiEfU7brFYEAqFWDzlqtRLnQKNpU/NTLMRRRFf/vKXce+996JYLOKP/uiPMDk5ib/6q7/CqVOncP/99+P//b//h4985CP4u7/7OwiCgAsXLjAfclLyHHftTnsIWl6Gtaj25dOKoZHZoNUw+m+1Yrhv3z7d4+Bo2UcRL8Xh4eESU2FaokuqCytB0uLllPfWNcpeiMISiQTVSIyFETULGv3ZWK1WNatBBkREo1EsLCwwOf+shiiKGBsbq/u4YrFoaipNPB7H4OCgmaeG++67b0ff4V//9V+rv5+YmMDPfvYzU9emARdFDbshhoTySJH4CUYiESpiaBRZltXZqEbEkNDI2aV2I6A1FtbSiD2VlmpRoiiKVceFiaJIdSA07Z8rLQcRLV6vl+q8U5vNRl24WYgszZ8NGUzQ398Pr9eLQCCwaxuDkZERXdOyyPADo9ysDhkAF0UAv5r6sbi4CKvVit7eXuaCRM4uSHREzHXrWSjRptw9wuygcDORACke2tzcrLsRoGXwWk0Ua1k4sRAxmrBwcWBRFLMXRJFVlbHH48GZM2dw8eJFJtcvR0/qFGjMIeNmHAYOtLgolrvcy7KMfD6/K6JUKBQQi8Vw+fLlik7zrNGKYaN+ioCxSE6SJMzOzmJtbQ2Dg4M4d+5c3VRdo9EQGQO3vb29Q/QLhQKSyWTVf0u7oIOF4NAWxWY/8wTo91ECbETRYrGgUChgcHAQS0tLJdWXLBAEoW5/IsFsn6LZM8W9QEuKYjVjX5vNRr3fq5xMJoNwOIx4PA6r1Ypz587tilMGqQyVZRlLS0uYn5+nIoYEPZGitsex1sCBatc3u2Btb28jEAjA7XZXbDKu18ifTCapFtvQXnj3QuM+C7FhIbQsrknS7xaLBWfOnMHGxgbTdaazsxOhUGiHTVSliLCR6lPtYPGbiZYSxXou97TL2rWk02mEw2EkEgkMDw9jYmICzz///K5EhySS2NjYKPEVpCGG2ntUE0Vt8U6tto5amIkUyeQbURQxOTkJRVGwurq643nXE0WPx0N15FezDwIgA7Vp4nA4qBoB0+q/LYfF91+7abHb7Xjzm9/MdErLmTNnMDExgWQyiVQqhaWlpR3OF0QsC4UCNxguo2VEUWsVVK2AhoUoptNptb3gyJEjmJyc3PU0aaFQwM9//nP09vaW+ArSpFKkqE3RmineqXf9aiSTSbWoYXR0VE3zlHvjVWvBYE2ztyawEO29kDImzg+0Kf++9/T0YHJyktlkm4mJCdjtdvj9ftU5BLj2MyBenMlkEuvr64jH43j11VdLhNLr9cJut9dcp1KpFLxeL5Pnf6NpGVHUM6SbZsFCKpVCOBxGOp3GkSNH0N3dvetiuLKygrm5OciyjFtvvZXpGYD2TFHrdt/X19eQGBIEQai7YGmb/UdGRkoWBGBnkY0sy7qElnZEshdSk7ShvRFIp9PU08asxsZV+vlMTk5ieXmZuoFzd3d31ckvgiCoNlukGf7SpUs4efKkaj4ciUSwuLiIXC4HURTV1CsRTJvNprqrNKOdGg1aRhSB+udSNCLFVCqFUCiETCajNp7XEkMyIYcW5Y7zp06dwtWrV5l/gIkoLi8vY3Z2Ft3d3VSj0lqRora/cWRkpOIGpFgslqRArVYr1tfXdd2b5oJOFhSa0BZt2p9JgP5GgHbLCMDOM7PSz8dqteLNb34zvv/971P9+emtOtVisVjQ1ta2Y7A+GYieSqWwtraGVCqFL33pS1haWkImk8Fjjz2G48eP49ixY7oHgtfzUgSAJ554Ao888ggEQcBtt922Y+INa1pKFOvRiCgmk0mEQiFks1ldYgj86lyERjO3Vgz9fn+J4zxr+yhFUZBMJrG9vY2+vr6qbveNUGlDQ0bgbW1tVe1vJJQXNugtdKDdA2iz2ahbErE6B6cFq7QkbViJYrWfj9frxdmzZ/H8889Tu5cZUayGdiA64etf/zpmZ2fxB3/wB1hbW8MzzzyDN954A5/97Gfx9re/veb19HgpBgIB/M3f/A1+9rOfobOzU/fGlSYtJYr1UnBmKhyd/xgdAAAgAElEQVSTySSCwSDy+TyGh4fh9/t177LJ/NNGRJEUj8zMzOwQQ+19WIiioijY2NhAKBSC1WrFwYMHMTw8TP0+QKk4aW2r9I7A06ZObTabbq9EmsVIAP2Fdy+4WeiZJ2oUFiLLqu+x1qZlYGBAPXdvFK/Xa8i+zUxGwGKxwO/3o6urC3/xF39h6N/q8VL8l3/5F3zsYx9TK1t3awi4lpYSRZokEgmEQiEUCgVVDI3SyGKhKArW1tYQDofR2dmJO+64o2oKg7YoKoqCra0ttez79ttvRyQSYWbKCvwqPTs7O4vFxUXDLR1aUYzFYrrvS7vKkbYosnImoQkLUWSxEWB1Tlnre2GxWHD69GkqbRpHjx419PwbccgwYxulx0txenoaAPCmN70JxWIRjzzyCH7jN37D8L0agYuiQeLxOEKhECRJwsjISEO9OmbseYgYzszMoL29vaYYau9DaxHZ3t5GMBiE0+kscbuPxWLMRljJsoy1tTVsbm7C5/Ph3Llzhgp3ZFlWFxybzWaoNYC2KNI+q3M6nbs6U9MMLArMaFeeAmzeSz0i5XA4qLRpGE2dNtKjyMpLUZIkBAIBPPfcc1hcXMTdd9+NX/7yl7va/tFSoqjny1nNFzAejyMYDEKWZQwPD1NpXDVyhqkoCtbX1xEOh9He3o4TJ07oPtymIYrRaBTBYBCiKGJiYmJHOTaLgc/a1DA52yCpFyMQQbRYLLrTpoS9MM2m2aEtiqw2X6x7FGvRaJuGzWbD6OiooX9jVhSj0SgzL8WDBw/i7NmzsNlsOHz4MMbGxhAIBHD69GnD9zNLS4miHkhbBjmXi8ViCIVCUBQFw8PDVHcsesRKe27n8/lw++23w+VyUb9PNeLxOAKBAARBqOl2TzOi0r7mjo4OnDx5EgBw5coVU9fTRoZGIwzaCzptUWQxl3U3W4eaBVYuHkY+b5OTk1hZWalocl2P0dFRw+ffZtOnZuee6vFSfNe73oVvfetb+MM//ENsbm5ienra1Ea4EVpKFPV82Un0Rjz9gGsT51n0+NWKFIkwhMNheL1eU2JIsFqthtNCpAG+WCxiZGSk7maAlovF1tYWgsGgelZJXnM+nze9aGUyGYiiaKqSba9EObRgcVa3F1pGWE2zMvLarVYr3vSmN5lq0zBTddqIl6KZ4ECPl+K9996L//mf/8HExASsViu+8IUvoKury/C9GqGlRFEPxWIRv/zlL2G325mJIaFSAQIZXB0KheD1enHrrbeasnbRYiRSTKVSCAaDyOVyGB0d1Z0mbnSnHYvFMD09DZvNhsnJSWrpWUVRkM1mUSwWTUVptCO7Zq/CdLlc1Pv/9oIomjnf14NRsfV6vYbdNCwWi+4B4FpuhENGPS9FQRDwxS9+EV/84hdNXZ8GLSWKtb5IkUgEwWAQmUwGQ0NDhkqbzaIdVUXEMBwOw+12UxFD7X3qLUxkHF06nVanwRhZeMyKViKRUM9qx8fHq6ZnzQ4Ez2azEEXR9Di3VhPFvTBcnAW73aNYi8HBQQSDQd2f2YGBAbXgzQiNOGTsxvp4o2gpUazE9vY2QqEQRFHE0aNHsb6+zmQ2aCVEUUQ6nVYjQ5fLVVLRSYtaqc1sNotQKKQOKjc7js7omaJ2JJueiNRsE30mk0EikTD87wg0F3QWPYXN3qOoZzxfM8DqHNXM58diseDuu+/GU089patNw2zDviRJpta6m9lLEWhhUSR9dna7HUePHlVHHG1vb+/KzlZRFHWCfSaTYSKGhErp01wuh3A4jEgkorp2NLIw6D1T1IrwyMiIrsk/gPlFiwxANoskSdQWTBYpumafo8qiOpaFgLEQ7kb6Mx0OB37t134NP/rRj+o+VpIkvPzyy/B6veqvalZR5f/OTJ0CF8WbDCKGDoejYmsBq6HAWkivn8ViQUdHB2699Vam99OKonY02uHDh3H06FEqi0y99Gn5SLZGRVgPsVisoUkhFouF6nOknaJrxGOyGrTP/+x2e9P3UQJsCqAa3RB0d3fj+PHjNauue3t78Za3vEU1yk4mkzusorTuFy6XS/1Mm02f3sy2UUCLiaIkSVheXq4ohgRRFBuKLGpBUrV2u11NeYTDYSb30kLOLgOBANbX1zE0NKRrNJoRqomiJEmYnZ3F2toahoaGMDY2xlwMtZWzjdDsI96IeS1NaKdjaUeKrFKxN7JHsRYTExNYXl6u2qYxOTkJ4NpntbOzs+QYotwqam1tDZlMBhaLBR6PB6lUCm63Gx6Px1AalYviTYTdbsctt9xS8zEsSrNJEY/NZitJ1WYyGeapWkmSsLCwgGg0iv7+fkOj0YxQLorFYhHz8/NYWlrCwMAAs/tqyWazCAaDSKVSat9WI551tMfj0a7qZOEp2OxFMSwqT1nNj6Uh4MRN47/+678qbjprnSdWsooCrn03U6kUrl69ilgshvX1dRQKBdjt9pKo0uPxVPzOmm3J2Cu0lCjqwWazUVsYIpGIOixbK4YEFjMhCUSUlpeXceDAAXg8npK5g7QhqTxZlrG0tIT5+Xns27cPd955J/OpK9rU7MjICHp6eiAIQsMGwrRF0el0UnWfb8Xh4izSsay+h7SiWo/HU9FNo62tDQcPHjR8PavVCp/Pp7ad2e12KIqCfD6vRpULCwtIp9NQFEVNwa6vr6OjowO5XE73NC0temyjAODf//3f8Z73vAc///nPcerUKcP3aZSWE8V61XA0UlJkJJrVasX4+PgOMSSwKLyQZRkLCwtYXFzE/v37ce7cOVitViwvL1O9TzmKoqBQKOD5559Hb28vzpw5Qz39WA4ZEL66uloxNdvogGUWotPM0NwQEmif1bHINrASRZrXHBwcVDebhEbP5bXN+4IgwOFwwOFwlJgbyLKMTCaDZDKJF154AT/4wQ+wtLSEu+++G8ePH8ett96K++67D4ODgzXvpcc2CrjWovX3f//3OHv2rOnX1SjNPV7/BtBI+jQWi+Gll15COBzG2NgYTpw4UVUQAbqFErIsY3FxEc8//zwkScLZs2dx+PBh5lEamcl68eJFFItFnDp1ytTIKSPIsoz5+XlcvHgRVqsVd955Jw4cOLBjgWhUFGnDoomdJiwEp9kjT5bQbuc5ffp0SbVoo96JehxWyPljX18f/vRP/xTf//73cejQIXz/+9/Hgw8+CIvFgmg0WvdeWtsou92u2kaV85nPfAaf+tSnTEWitOCRYhlmRDEWiyEYDEIQBOZTcMrRmgv39PTsSoRGKB/JdvnyZermwlrIa52ZmUFPTw/Onj1bs3qOpZWVGWgLRCqVoipkLCLZZh9WAEAtPqEN7ddut9vx5je/GT/60Y9gt9uZeZfWIp/Pw2azwefz4a677sJdd92l69/psY16+eWXsbCwgHe+8534whe+QPV5G6HlRLEeRhYG4pyhKMoNEUPip9jV1YVTp07t2tCBaDSKQCAAu93OtL+SQPwb0+k0IpFIRSPlSjRbpEh7kWx22yhRFKmLGAtR9Hg8VM96AXbG3t3d3WqxoJl2ikYx66VYD1mW8ed//ue4cOEC9WsbpeVEkcZumIwm0zssux5GKuoqOUiwjM60JBIJBAIBKIpScyQbTYgAOxwOuN1u3UaqxWKx4bNh2j6KzT7NhrbgsKjkZtFPyEJoWVZaHzt2rGpLmV7MVvGabdyvZxuVSCRw5coV3HPPPQCA1dVV3H///fje976368U2LSeKeqn0odGKIS1PRdLKUO/sTzsovK2tzbBrRjWfSD2QkWy5XK6usTKtknnSayjLslq5+8ILL+hewGikTmkuwLSLqliILO2ok1UhGW2avcimHKvV2vDsUbO2UbFYjIltVHt7e0m1+D333IO//du/5dWnzQKZ40k+NIlEAqFQCIVCoa4oGIXspmt9QLVu92YHhZN0jhFRNDqSTa/A14JYdqVSKYyNjZW810TY9VyfRuqU5oJOu+CJRRRG+3osoiUWosiiN5N1gVGjRyWN2EaZEUU9tlHNQsuJol5PxUKhgEwmg2AwiEKhgOHh4ZJSZVrUOnvQNv3XmsJj5D56inDy+TzC4TC2t7cNzUUt30wYgdyTzGIlvYZajDhxNCqKtEVsr1gd0YSF5yGLHkUWQmu325mdadvt9oY3HI1EimaPi+rZRml57rnnTN2DBi0ninp57bXX1DNDFmJIqLTjJ9WsFoulYtO/GfQc/GtHsh0+fBjj4+OG7aP0Cq/2nnNzc2qvYa17GmlhaTR9eiOKGIzAYo5qs59RsmgvYiG0AFszaRrtCmYjxZt9GDjQgqJYa5FPpVIIhUKIx+M4cuQIBgYGmDdcaxuHtd6CtKtZa4midvrNoUOHTI9kMxLJkb7KhYUFHDhwQNc9jdhHNbpLz+Vyu1bAZAYWkSftkXHpdLqpB6oDbIQWAPX3UovVam347N6swXAsFispkLkZaTlRrAQpJMlkMhgeHlYrHXdjAonVakUymcT8/Dzy+Tz1M0vtfcpFUStM2uk3ZtEjitq+yt7e3rq9hkavT2hUFNva2qhGEM3uKcgqCmv25n0W33FZlpn+vKPRKFZXV2G1WtU5peSX3u9SIw4Zx44dM/zv9hItLYpat/nh4WG1kCQej+/KeQ0xGC4Wi5iYmEBXVxeze2lNgLVN8DRHstUyGibVs8FgEB0dHab6KvUa1pI5jo1AOypp9mk2e6Fxf6/AegM0PDwMj8cDSZJKHDBCoRCKxSKcTmeJUGrtogiNpE9v5mHgQAuKoiAISKfTCIfDSCaTFd3mWVT2adFWdba3t8Pn8zEVRODaIi9Jktrw39nZidOnT1Nt+K92LhWNRjE9PQ2n04nbbrvNVPUsub7eSLTRhYm2SOyF1gSasDiTZfGaWfU9sswykbS+KIpob28vOWZRFAXZbFb1VtTaRWkNiPP5vKnjgZvdIQNoQVEsFAq4cuUKhoaGMDk5WfHDa7PZmFSOEbf7aDSqVnUuLy8zPX/Q3ntqagpdXV04ceIEk9mC5aKVTCYxPT0N4FrDcaMFQ/UKbWKxGKanp6ksyLR3+7RFsdmLYlhsLGmPtQP2nihardaan29BEOByueByuSraRSUSCWxsbKg9gevr6yVRZb1jIx4p3oTY7XacOXOm5mNom7fWcru3Wq1Mx5GRiTCFQgEHDhxgOi+RiCJpZclkMhgdHaV2Rlqt0CadTmN6ehqSJGF8fBzpdBqzs7MN3YumSOyF1CRtcWDRMsKifaLZ21rKMbuZJXZRZAqVIAjo6uqC2+1Wo8qNjQ2k02l1CLhWLMnxCo8Ub1JYDAWvRKFQwOzsLDY2NjA4OFjRdZ5VqpaMZAOAo0ePIhaL7coZj7ZgqDwt3SjlkWg+n0cwGEQ8Hsfo6Kiago5EIg3fq5mn2dQ6uzUL7c8Gi5YRFsMFWESKu5E6bRRypuh0OuF0OtHd3a3+HYkqiVDOzMzg8ccfxyuvvIJEIoGnnnoKJ06cwPj4uO6sTD0vxS9+8Yv42te+BlEU0dPTg69//et17ahY0ZKiWI9GhUrbezcwMIBz585VXSRoV+ilUikEg0Hk83mMjo6qu7pkMslseDR5vUtLS+jt7cUdd9zBZGEgmxltP+WRI0dw7Ngxqj6KAH1RpEmxWKT+/u5GCr8RWGweWYkiS2iJYq3q0/KoEgBuv/12zM/P433vex8WFxfxgx/8AFNTU/jkJz+JBx54oO696nkpnjhxAi+++CLcbje++tWv4i//8i/x7W9/m8prNQoXxQrYbDZTi4S23+/gwYO6eu9oRRHZbBbBYBDJZLIkatLeh0XKjRgaHzx4EIcPH4Yoisx2yoIgYH19HdPT0zXfXxpzT2m+V7TfD7vdTlXEWDTu02avjIxjXWRDqxbAaPWpxWLB4OAgLBYLPvWpTxl6jVovRQCql6JWFH/9139d/f25c+fw2GOP6b4+bVpSFGmnT6u53euh0UixfCRbteIhmqKobeno6+tTew0XFhaYLTTr6+tYXFxER0dH3d7GRiPF3fKjNIvZTVs1WDTu0/4csBAat9uNdDpN9ZqsJuQQaEaKRjMYZM00+rPQ46Wo5dFHH8Vv/uZvGroHTVpSFOuhV0BkWcbS0hLm5+fR399vqBFdey8zkSI5r1xfX9c1ko2GKJb3Gpa3dFitVuoLQiQSwfT0NLxeLw4ePAiPx1PzPc7n8w0vyGRiSKvAonG/2SNPVrCMEgVBoNZCZcYxJ5VKMfdOfeyxx/Diiy/iJz/5CdP71KIlRbHeB7fe3yuKguXlZXUqSyPN70ajUrMj2RoVxUgkgkAgAJfLVdW2imYajrRzCIKAyclJeL1ezM3N1RU8GqlT2oUxzS6wyWSy6fsyWbyHLK7JsprV4XBQ/TkZvZZZg+F6XoqEp59+Gp/73Ofwk5/85IaOWGxJUTSLoihYXV3FzMwMurq6qDS/6x1yTUayzc/P48CBA4ZHspmtWNRWsdbrNaRRuEDORtPp9I52Dj0TbWgU2dAWRdqpRNrX83q9SKVS1K7X6o37rKApFGaep9l2jHpeigBw+fJl/PEf/zF++MMfore31/A9aMJFsQbk0JycaYXD4V13u9dGpX19fTh37pypRcdopJjJZBAIBJDNZnX3GjYiioVCATMzM9jc3MTIyEhV66h6r4GGKNKOmpq9p5A2tM88ATbpWBZRHcszRVprjlnhjsfjpiJFPV6Kn/zkJ5FMJvG7v/u7AICBgQF873vfM/U8G6UlRVGvN6AkSYhGo6rbPatJMJUgQhwKheD3+xuOSvWKYj6fRygUQjQaNdxraCYalWUZ8/PzWFpawuDgYM32FT29ajTSp6SBmRbNbgbc7CJL2nBoIggCE6FtdssooDm9FJ9++mlT12VBS4qiHhRFwYsvvgiv12va7d7o/UhUurW1hWAwiLa2Ntxxxx1Uvgz1oqxyL0Xt1B1a99CirWDt7+/XlQ7WYx1FI1J0OBzUIh29Q8yNXK/Zp7pks1mqxTu0J0wB16JZFpEiywKjYrFoqkCm0nXMZJtisdhN76UItKgo1lrsidt9LpfDsWPHdiW/TdKO8XgcgUAATqeTuhBXO7vURmqNeCmSe+hZsDc3NxEIBCpWsDZ6fRqiSDNKpN10ziI1SVscvF4vMpkMteuxaBlhMYYOYHumSOoZAJSMYWtrazNs7M0dMqrTkqJYiVgshkAgAKvViqNHj2JhYWHX+tUURcHly5dhsVioDM7We09yVmm2naSceqJFBnbb7XZTbhn1oq5isUhloaMZiTW7GTCLxn3awsCicZ/FNW02G7NIURRFTE5OArj2+SRj2La2tjA7OwtJkuBwOHQN924kUuzv72/4tTQ7LS+KpLpSURSMjY2pB8ksduTlkJFsmUwGhw8f3pUPnKIo2NjYQCgUom4fVe1MMZ1Oq0PJx8fHTR3WA/VFl9ZgdZoLG233+WYXWYC+KLL4HrLoJ2QhtATtEYrFYkFbW1vJ5llRFORyuYrDvbVC6fV6IUmSqfR2PB7n6dObFUEQkEwmEQwGUSgUSmaEElh6KmYyGYRCIaRSKYyMjKhT6VkjSRIuXboEt9tdtdewEcqjDm3RzujoaMnQYbPXryaKxWIRc3NzDV2/3j3MQLvdgYUo0qZVexRZimK9ylNBEKoO99Z6K4ZCIeRyOVgsFlitVlUonU5n3c9WKzhkAC0qipIk4erVqzhy5Aj8fn/Fx7AQRa1IDA8Pq20Ha2trTJt+E4kEpqenkc/nceLECWbpWSIoxWIRs7OzWF1dNV20U4lK6VNFUbC0tIS5uTkqu1gWPXbNDG2RZVHVyaIoptkrbssx245htVp3GBEvLS0hm83C4/EgkUhgZWUF2WwWoiiWRJQej6dk08QjxZsYm82GU6dO1X0MrR2+1kJqaGhoh0iwikrT6bRaNDQ6OoqrV68yj0iz2SwuXryIAwcONFS0U4nyKI4U7Pj9fpw5cwYLCwtIJpMN3YO2a0mzmxXTRhRF6q+ZhYC1ajsGcO15ut1u9Pb2lhQSSpKEZDKJRCKBpaUlpFIpyLKM1157DaFQCNvb28hms4aHntezjcrlcvjABz6Al156CV1dXfj2t7+NoaEhWi/XMC0pisDueCqSlN7KykpNCynaDha5XA7hcHhHryG5D+00j7anslgs4q677mJSpEQqaBOJBKampmCz2UoKdmhVntL8WdBeKGk3htMWMBbtEyw2AnutHYPmsBBJkiqKrCiK6OjoKEmRyrIMv98PWZbxzDPP4NOf/jRWV1fR09ODj3/84/it3/qtmvfSYxv16KOPorOzE8FgEI8//jg+9alP3TDbKKCFRbEejYgiGcm2sLCgayQbrUhRkiTMzMxgY2OjYtqSiCJNwSIDuz0eD+644w68/PLLzKp28/k8tre3kclkMD4+viOV02ztGAD9hZJ2VoG2aLMo3KH9HrIa+M6qMM9isVD9Thlp3rdYLBgZGcHIyAguXLiAH/zgB7BYLNjY2ND12dFjG/Xkk0/ikUceAQC85z3vwZ/8yZ8wt+CqBRfFKpjZ8ZaPZNPb5tBopEh6DRcXF2tGpLQHdpOqXTKwmxWSJCEcDmN9fR0OhwOnT5/e8YWRZZlKFNXsg7Gb/Xq03z8WY9NsNhv1a1osFmaiSHsQuJk+xXLbqJ6eHl3/To9tlPYxoiiivb0dW1tbDRfmmaVlRbFe+tTI4b6iKFhbW0M4HDY1KFwURVPjycp7DevNRaWRpiUDu1OpFMbGxnTNRDWLNuIeGBjAHXfcgatXr1ZcIGiMd6MN7Wk2tM87AXbRDS1YVMeyqBJlESETaM9ZNtu8fyOjt92kZUWxHnrSVNqRbD6fz/RINqMpMdJrGAwGDYlwI6JIorXNzc2aZsY00J5R9vT0qBF3LpermrKh1aNIE9qpTtqiuBcWuL3SuM9yU0ZbFM3MPjXb26jHNoo85uDBg5AkCbFYDF1dXYbvRYuWFcV6C0K94dbEX5DGSDYjYrW9vY1AIKCe4RkRYTOiqB0DVys1S4toNIrp6Wm43e4dr69W5EVrUaJ5xkb7fWKRmqSdPt0L5sIszhNdLhfS6TT16wJ0K08Bc5GiWYcMPbZR999/P77xjW/gzjvvxHe/+1285S1vuaEbtpYVRbOQ+aQ0R7LpWZxIr6HFYjF9hmdEFIl3ZDgcNjwGzkyaJZ1OY3p6GsViser7WquxnlakSPOsifYXm7bIskhNtqooslzEWUSKRj9LZhv39dhGfehDH8KDDz6IkZER+P1+PP7444bvQxMuijpJpVIIBAKQJAmjo6NUm1hriRUZkZbP5zE2NtbQffWK4tbWFgKBANrb2w2fjxLh0rvgagcajI2N1Uyb1BLFZj1TbGZoPz9FUfaEd+Re61Fk4d1q9GffiENGPdsop9OJ73znO6auzYKWFUU9HwpBEJBKpTAzM6OOZGOR664UKeZyOYRCIcTjcfW+jS5i9UQxHo9jenoaNpvNdEpYrygWi0XMz89jeXlZ99SbWulTGpEi7ciJpWNCM2K326m/5r1iLswqQhYEASsrK2hra9sxYWY3aZVpNkALi2I9crkccrkcXn311apO8LTQimJ5r+GxY8eo3bdahVwmk0EgEEAul6MSjdbaNWt9FPft26fLR5FQ7X1QFIWKKNIe8dbsk11asXG/moVaIyiKwrTylIwyJBNmym2jjGRyzL72VvFSBFpYFKstsIVCATMzM9jc3ITD4cCtt97KfDQaia5mZ2fVnh0WBS1Wq7UkzZjP5xEOhxGJREom3zRCrV7IRtKytSgUClQWOtqThZLJJNWfIe1ohEVTPE1xYDVHlbaAseilJHi93pJqTVmWkU6nkUwmEYlEMD8/j3w+D4fDgba2trq2UUaONrS0ipci0MKiWI4kSZifn8fKygoGBwdx7tw5vPbaa8wLB8p3gUYiJ6OQRV87fm5oaAjj4+PUotFK537JZBJTU1OwWCy45ZZbqG8yaBXZ0BZFh8NBdQFu9kpR2pkUFt89VobFrCivPNVaQREURUE+n0cikdhhG6UVSmIbZSYjEo1Gd8VwvRloWVEkX2BZlrGwsKD2z2hFiaV9lLYXr6urCx6PRx2FxApBEBCNRnHx4kXs37+fiQBrRTGXyyEYDCKZTDJt9Kclis08zYZ22k9RlKYfLu5yuZDJZKhec6/0PRL0FNkIggCHwwGHw1EyBUaSJKRSKdUJI5lMQpIk1cWGCKaeeyQSCYyMjDT0WvYKLSuKZFrK3Nxc1ZYDVkbDlXoNt7a2qN+HQJr9SbR25swZZvNJyU48GAxifX0dR44cwcTEBLPz2EgkgnA4TOVaNJ8j7cHitK/HIuVH+6yOpdjQpFnbMcjINO1ZYCwWw/z8PJxOJyKRCBYWFpDL5eBwONQzykrp11gsxnR6VTPR0qKYyWRqnm3RjhRJdacoijh+/HhJGlEQBMiyTH0hIM3wLpcLx44dw/LyMjNBVBQFqVQKV65cwdDQENNG/3Q6jampKSiKgvb2dsRiMSb3MQvtNJ0kSdRFmzZ7waOQxXNkVWVstVqpf1eLxSJcLhf6+/vVPyPpV2IbpU2/rq6u4urVq1hfX2+oBmB7exsPPPAAZmdnMTQ0hCeeeGKHyL7yyiv46Ec/ing8DqvVik9/+tN44IEHTN/TLC0rijabDaOjozUfQ0sU9fQaknvRKj5JpVKYnp6GLMtqM3w6nWZyTqMoiuptaLFYMD4+XvKlo32vq1evIhKJqH2Nv/zlL6ldmxa0RcftdlNNJbI4B6OdjmUhNmSxpwmrugMW/YmVRrxp06/aljNJkhAIBDA1NYVgMIiPf/zjAICxsTG8//3vr2sbpeX8+fN461vfiocffhjnz5/H+fPn8fnPf77kMW63G9/85jcxOjqK5eVlnDx5Evfee++uF/i0rCgC+oaCN3JeVd5rWGvqOy1R1J7jjY6Owu/3q39Hu5AEuJZWmZ6ehsPhwIkTJ7C0tMQknUTOflOp1I7iIFqN+zQXYRaO9s18vTX1DPMAACAASURBVFqDFczCIqoTRZH6dVmdzbIQRSOFNqIo4tixYzh27Biee+45fOc734Hf70cgEDD8+XnyySfx3HPPAQA++MEP4p577tkhimNjY+rv9+/fj97eXmxsbHBRbCbMRorato4jR47o6jVsVLC0/Y3VzvFoiqK2t3F8fFydi1ivT9Eo2oKk3t5eeDwe7N+/X31tkiRRW5Raadg2i7YE2mJDewPHQriBm1cUtSQSCbS3t8NqteLo0aOG//3a2hr27dsHAOjv78fa2lrNx1+6dAn5fB7Dw8OG79UoXBRrYFQUtVNajA7PNivA2urZev2NNESxUCggHA5je3u7Ym8jzYIQEoU6nU61IGljY6NktipNdwyaizCLBnGasGhLoL0Zoi02LKrJWWRfCLQHgQPXPuNmxFaPOfnb3vY2rK6u7vjzz33ucyX/LwhCzU3jysoKHnzwQXzjG9+4IcVWLS2KtDwVZVnG8vIy5ubmDE9pIRj9cpGB3TMzM+jt7dU1sLuR6EXrljE4OIixsbGK16OxG89ms5ient4RhWqvT74stFKnzT7NhvbCa7fbqW4oaBcWsZiOY7Vam96kWUuzRIqKouj6PD/99NNV/66vrw8rKyvYt28fVlZWqvY8xuNxvPOd78TnPvc5nDt3ztDzpEVLi2I96n0xtebC3d3dDbU6GNnFkskwPp8PJ0+eZPLlIWhfox7xbcSBXJsCrjZar7xfj9bCbsZjrhbNnkps9sZ9Fk32LKIOt9uNZDJJ/bpAc4ki0NjPmNhDPfzww/jGN76B3/7t397xmHw+j9/5nd/BBz7wAbznPe8xfa9GaWlRrPdDriVURJja2tpMmwtr0bOLJfZRVquVyWSYciKRCKanp+H1enWLr5lIkUz1mZubq5sCJq0rBFqi6HQ6qQoZ7fNJ2qld2hEO7Z5HFgLW7Oe8WhwOB5Pna2bzl81m4XK5Grrvww8/jPe+97149NFHMTg4iCeeeAIA8OKLL+Kf/umf8LWvfQ1PPPEE/vd//xdbW1u4cOECAODChQu4/fbbG7q3UVpaFOtRaYpILBZDIBCAKIpUhamWqzrNgd16IO0ciqIY9m40mgYmrRx+v19XpF0uurREkXYzO03RoX1utRca91kIAosWD1a9mayyP2YiRRrDwLu6uvDMM8/s+PNTp07ha1/7GgDg/e9/P97//vc3dB8atLQoGvnisfRTBK4tVOXnY4VCAaFQiOrAbqC6CXA+n0cwGEQ8HsfY2FhJO4de9EaKZB6q1WrFbbfdptumqvwcuBl9FGlPn6Etiix6FFkOxabFXvFmBK5laba2tkrcMLxeb8M/O0mSDF+jlRwygBYXRT3IsozXXnsNiUQCo6OjTPwUgdKFT1vFympgt/aLoR0Q3qhdVT1RJMKbSCQwPj5uuAdJe31ZlqktxDSFotkHTrNITe6Fxv294s0IAENDQ2hvb0cymUQymVRnl8qyDLfbjba2NlUojfQ2m3HJaCUvRYCLYlVIr2E6ncbw8DDT+Z3Ar4p6lpaWMDs7y2xgNxFfq9UKRVGwvLys3u/OO+9seMGsJopa4dXbu1nt+mTBbMYoEbhWfJFOp6ldrxUb92kPAhcEgbqAsbgmweFwwGq17phdSsZTJhIJbG1tYW5uDoVCocQ6qq2tDU6ns+rP2ejPPxqNclFsFSp9OLRR2uDgIDo7O6m43tdCURTE43Gsrq5CFEXmA7uLxaJ6ltfZ2UnV27A81UdaR8LhMBXh1Rba0GwpaOZpNs0Oi8b9eu1SRql1Zt/INXe7cd9iscDj8cDj8aijFBVFQS6XU62jVldXkc1mIYpiiVDqPaIop5W8FIEWF0UtsixjaWkJ8/PzJVHa5uYmCoUCNdEohzSok4n24+PjTO5DkGUZv/jFL+BwOAyd5elFGzWQ6tW2tjZqwqu9fqs07tMWHNrPj8V5Iu3XzKLJnpWPoiiKhophBEGA0+mE0+lET0+P+ueFQkEVyrm5OaTTaaRSKbzxxhsl6dd6r4NHii0E2Y3W6jVktRskhTvFYhFHjx6Fw+HAq6++Sv0+hGw2q57ljY6O4uDBg0zuQ/oUX3nlFRSLRcPVq/XQRhDxeJzadWnbPNGE9hBrFuPTaMJCZFkIGKuMAK3KU5vNBr/frxbMFYtFXL58GQcOHEAikcDq6iqSySSKxaJ6TkmiSu0GNpFI4PDhw1Se016gpUUxn8/jhRdeqNlrSFsUtUPCtYU7xWKRWSEAaYgfHh5W0y8sICPgYrEYTpw4waQoyWKxIJvN4tVXX6VqLkx7RBlNHA4H1eKdvdC4T5tUKkVdvFlZRrFqxygWixBFET6fr2RKlPacMhKJYH5+HoVCAevr63j22WeRSqWwb9++qlXr9dBjG0WIx+OYmJjAu971Lnz5y182/VobYW+4eDLCZrPhtttuw+TkZNXme1pGw5IkIRgM4qWXXkJnZyfOnj1bIhq0ixXIWLYXXngBDocD586dQ19fH5M0kizLmJubw6VLl9TdJgtBlCQJ0WgUwWAQ+/fvp7qjpgnt95fmpoxF4z5tWERgjTafV4KVKLKYeQpU71EkG+X+/n6MjIzgxIkTOH36NM6ePYvTp09jdXUV3/zmN3HixAncc889al+hXohtVCAQwFvf+lacP3++6mM/85nP4O677zb82mjS0qJosVjqflkajRS14mSz2XDu3Dns27dvxxef1kJAXCUuXryIXC6Hs2fPYmBgQN0l0yw40N4rn8/j7NmzOHjwIJNh2EtLS3jhhRdgtVpVH8VmnXtKOxVL2+ex2YeV75VpNnvJHQMw1qMoCAJ6enrw+7//++jp6cE//uM/4pVXXsF//Md/4G1ve5uh+z755JP44Ac/COCabdR//ud/VnzcSy+9hLW1NbzjHe8wdH3atHT6FKhf5WZ2MLH2rLKnp0fXwO5GicVimJqagsvlqpoOptVYHo/HMTU1VeJgAegfHqyXSCSCqakptLe348yZM1hYWICiKMhms9TuQzt6prlY2mw2qudre6H/by88R2DviSJJnxolFoup1afaM0q96LGNkmUZn/jEJ/DYY4/VHCy+G7S8KNbDZrMZ7jnb3t5GIBAwNDO0EdLpNAKBAAqFAo4dO4a2traqj21UALLZLAKBALLZ7A4HC4DejjydTmN6ehqyLKvj9BRFgcViwcLCAtUiG5qRCYtpNjRxOp1IpVJUr8kiHU8b2gImyzIT8RYEgVmlu1kvxXg8XvUMkNCobdRXvvIV3HfffcwKAI3Q8qKoJ1LU+4UiA7stFguOHz9uuKCFFHzoXaS1Y+BGR0fR3d1d99+YdR+QJAmzs7NYX1+v6mBBA0mSEA6HsbW1pb4mRVFQLBYhyzL27duHtra2uialRqD5OvbCDFCasGjcZ9E6waL4iWZLkPa6rH7mZkUxnU7Xbd1q1Dbq+eefx09/+lN85StfQTKZRD6fh9frrXn+yIqWF8V66BFFEj1lMhmMjY2ZbnQl96q3UySFLWbGwFmtVkNfZq2DxcGDBw0ZJxuh3Cnj7Nmz6iaB7MoFQYAoiujo6EAikaAaLdKCRRN7M7MXzupYeTOygGVWyYxDBtlMNPKd12Mb9a//+q/q7y9cuIAXX3zxhggiwEWxLrVEkbQgbG1tUYme6qU2tdNh+vv7mZsZb21tYXp6WreDhVm2t7cxNTVVch9FUVRBFARhx5eS5og3mlEES3+9ZoTFCDoWkSJtUWS1WWFVeQpc22yYHdbRyOvVYxvVTLS8KNb7YVdqydBGarVc6I1SS4C3t7cxPT0Nn8/X0HQYPaJo1sHCKOl0GlNTUwCg3kebKgWqn0HQFEUWaTBa0I48aV/P5XJRnVPKYhzbXrGhAq4VlgGA1+uF2+2mmpUx45BBNqWNoMc2SstDDz2Ehx56qKF7NkLLi2I9tEKlHaC9b98+6gO7Ky0IyWQS09PTEASBin9jLVHUOliMjY3VPVyvRa1GXxJhb29vq+0VesWQQFMUWfRu0qKZex4B+uKwVybPsPJR7OzsRC6Xw+bmpjrJSDtpxuv1mhZKM9WniUSiZuHezUjLi2K9LwwpxNnY2EAwGKQ+QFuL1WpVF61cLodgMIhkMtmwQJXfo/wLrY18G3GwIJBeuPJrKIqCxcVFzM/PqxE2ub/23LDevSVJatpZpc1cdMKicZ+24LBwPtkL1ayEnp6eko2BJElIJpNIJBJYWlpSU/Mej6dkfqkesTNTaNNqc08BLop1icViSKfTWFlZYZpKBH418zEUCmF1dZWJZZW2ZUB7Rkkz8iX30O5oyflkV1eX2rNZ79ywnEwmg6tXr+L1118HcG1hIIOQHQ4HRFGE1WpVryPLcl1RYTFJiBa0z9dYzBRl0bjf7C0erKYC2Wy2Hd8/UlimLd6TZVn1WVxbW0MoFCqZX0p+ldcAmIkUW81LEeCiWBXSJydJEpxOJ2655Rbm9lGJRAILCwsYGhqi4m1YCZKijUajmJqaoupgQdAKTSqVwtTUFCwWi+FzQ+BaSnd6ehqvvfYawuGwqQWTuJd7vV5VSB0OB+x2O0RRVO9f/jzKRVsPmUyG2ueE1ohBAovPL20Bo/2aAfpRnc1mYxLR6q08tVgsNeeXbm1tYXZ2Vl27iEjm83nDawqPFFuQ8oWCRGqxWEwd2H3x4kVTjtV6IalZm82GgYEBDA0NMbkPcC09FYvFEAqFqDtYECwWC/L5PGZmZhCNRjE2Nga/369bDIvFIkKhEK5cuaIOJWgEsqvWPr/9+/ejUChgc3NT1zWsVivsdjucTifsdnvJL1EUYbPZ4PV6oSgKnE4nLBZLwyJEu2qSdpQI0BccFg4etCNFFptVoLF2jGo+i9lsFolEArFYDKlUCi+//LJqSExSry6Xq+pntdW8FAEuiiqSJGFubg6rq6s4cuQIjh49qn5QyO6VtiiSUWkOhwO33367mqplgba4xWaz4eTJk0zuI8systksLl++jOHhYdUfst65oSzLmJ2dxWuvvYapqSkmFaEulwt9fX3Y3t7GysqKoX9bLBaRyWQqVlr29fWhWCxia2trx991dHSgv78fPp8PTqcTNpsNFotF18JKe/H1er1IJBLUrseiKZ5FqpN2hMxKFGm3YwiCAJfLBZfLhd7eXmxtbeHMmTOqIXEikcDa2hoymUxFQ2KLxdJw+lSvQ8b8/Dw+/OEPY2FhAYIg4KmnnmIaHNSi5UVRURQsLCxgfn4eBw4cqJi2pG0flc1mMT09jVwuh7GxMfVDl0wmmYyjWlxcxMLCglrc8vzzz1O9B2FjYwOBQACKouCWW25BZ2dn3XPDfD6Py5cvqylWQRDQ19eHXC6HVCqFZDLZ8MLb1dUFj8eDtbU1LCwsNHSt8uuKooj19fWqj4lGo4hGozv+3O12o7e3F+3t7XC5XGrUySobwQKbzdb0Dh60nyPQ/D6Keu7jcDhKJmCVGxIvLCzgkUceQV9fH/bv348XX3wRx48fNyzcxCHj4Ycfxvnz53H+/Hl8/vOf3/G4D3zgA/j0pz+Nt7/97Ugmk8w2HnpoeVGUJAnZbLbmwG5aolgoFDAzM4PNzc2Kzf60HSxIWpb1QHLS1yiKIk6cOIFwOAwANVOlhUIBly9fxqVLl2pGxw6HAx6PBy6XSz3/KxaLJaJZCUEQcODAARSLRayvr1cUJrN0dHTA7XYbjja1pNNpzM7O7vhzURTR3d0Nv98Pm81WsmtvFBZu9jQFh8XkGRaiyKodg2Xjfj3KDYknJydx7tw5fPazn4UkSfjqV7+KK1eu4OTJk/jKV76i+7pPPvkknnvuOQDXHDLuueeeHaL4+uuvQ5IkvP3tbwcAJkc6Rmh5UbTb7RgdHa35mEa/rLIsY2FhAYuLixgYGKg6Ko3WIqNNy1Zzy6CB9vx1fHxcjQwFQcDa2hoURYHX6y2JfgqFAl555RVcunRJ12BqWZbVVE8lXC6XWjwjiqLaDqIoCuLxONU0rNfrRUdHB5aXlxGLxahdVwspRHr11Vd3LL4dHR3w+/1qNaLH44EoiroXaRbndTRhMXmGBSxE0WKxMJsYBcDQTGVCR0cH7HY73v3ud+Pee+8FYLzaWI9DxvT0NDo6OvDud78bMzMzeNvb3obz58/fsKxJy4uinlSI2d0m8RsMhULo7e2tG601GpFqHSy0aVnaEI/IpaUlHD58GEePHlX/XJZlHDp0CBsbG1hYWEAymYTVaoXb7cba2hpef/11quemxWJRHVicz+exurq644tL7k8qTq1WK3K5HPL5vLoQ5XI5pNPpiguey+VCT08PlpeXsbS0RO25a+nq6oIgCDWvXy0Va7fb4ff70dXVhe7ubvh8PtjtdhSLxZL3otknxeyV1PGNrDw1i9lh4IlEoqTQptLPvFGHDEmS8NOf/hSXL1/GwMAAHnjgAVy4cAEf+tCHDD9fGrS8KAJ0nTIIpOXB4/HojtbMTlYx42BhpgBBm5Lt7e1V+xrLzw3dbjcGBwcBXFuIL1++jB//+MfUi4hIo/Pq6mrNs8JisVgz2tTicDjgcrnU/5LXlcvl0NbWhmw2Sy36VBQFfX19yOfzWF5eNn0dshmotDD5/X709fVh37596jQUVum/RmHR+8eicIfFiLdmFcVYLFZ3c92oQ8bBgwdx++2348iRIwCAd73rXbh48SIXxWZGFEXdu0PS31gsFjExMWFoRJJR8dWOnTPiYEGm2hjZmScSCUxNTcFut6siX6vFolgs4he/+AUuXrxIteKRnOdtbm42JCTVyOfz6OzsRD6fx/z8fMUFUBRFdTal3W5X33NJkpDL5ZDJZGpubgRBQH9/P2KxGNXCn0pEIhE4nU7MzMyom5ZDhw5hYGAAbW1tDUWPtAWHRQTGoo+SxfNkfZ5oxiED0OelWAs9DhmnT59GNBrFxsYGenp68Oyzz+LUqVOm79koXBRRP1K02Wx1nQ8q9TcaxcgunkyI6ezsNOxgQaaG6PmSaOehjo+Po6Ojo64YXrlyBa+88gqKxaJ65kcqS4mAlL/n5JqFQgGSJKmj3EhE6/V6kclksLGxoft1GsHn88Hr9WJ1dbViAYwWSZKqpjIJbrd7x1mnLMtwuVzqRoY1nZ2dcLlcJb2YiqJgfn4e8/PzAIC2tjYMDAygt7fX8JkWbcHxeDxUDZAFQaAefTZjj6IeGjEYbqRPUY9DhtVqxd/+7d/irW99KxRFwcmTJ/GRj3zE9D0bRTCYCmAzGv4GUygUaopRJBLBysoKJiYmdvxdsVjE3NwcVlZWcPjwYezbt6+hs5b/+7//w1133VX177UDwsfHx02Nnbt8+TKOHj0Kl8tV9THl81C1DcGV+g2LxSL+f3tnHt1mdaf/59W+2dos72u8O4RsThzSJkDTsLR0OAVKS0tLyzC0p8k0LdBSymErQ0qBsoQuLIGhA+2P0r0DMzlzmDaUJXFIIIkz8RavsS3L2vdd7++PcG8lR7Yl+ZXtOPdzDgdiYutKlt7nvd/7/T5PV1cXOjs7BdsZmkwmxGIxWhZMHpQnZ4PkwhcMBuH3+7MqbYnFYhQXFyMYDKYtPQqJWq1GeXk57HY7CgoKoFarEQ6HMTk5KfjOg+M41NbWwmKxZCUKYrGYCmRBQcGcAkAivoRCJpMJ2hgllUoFF26FQiGocBOKi4thMBjyJo5WqxVer5eWKDNly5Yt+PDDD5d8rmeGZPQk2E4xA9KVNXmeh9lsxtDQEMrLywVPzJiOkAkWs/lLJjcHlZSUzHhuSC6YpEx66NAhQcSQGB3bbLazSovhcHhWAeE4jnqhJhIJSKVSKJVK8DyPSCSCUCgEn89HZwPJ7y/fFBcXQ6FQ0OH+5PNNhUKBsrIyyGQyeDwe2rWbK1qtFhqNJqeGoHg8jqGhIfqaFBcX0zIrGYch5GNwPx/hwku9uYjg9/thsVgQDodTrNkKCgogl8vn/bi5+J7mKx5rqcNEEdlnKpLSpU6ny1tiBiF5x1ZXVzfvBAtg5oYer9eLnp4eKBSKOc8NY7EYurq6BBFDjuNgMpkQjUYxOTmZ1hkmE3ien9F1Bjhz6C+VSulOdyFYsWLFWTZzyfA8D4fDQf9sNBppidpqtcLj8WT8WLW1tbBarYKVmKempqgxgVwuR3NzM4qKiuhrKPRN4LlQ6szH+0Ymk6GhoYH+/GTHmYmJCYTDYchkshShVCgUWV0Hci2fAvm7EViqMFHMALJT9Hq96Ovry2v4LsdxdDdGHPCFzm6cLorhcBj9/f0IBAJobm6GVqudVQzJznC+CfOkjGixWOgZVz7Q6XQIBAIYGxtL+bpYLEZVVRVtWBI64aKlpSXtXNZsRCKRFIecsrIyFBQUzFpqLSgooPOT+SIcDuP48eMAzpy/lpWVQaVS0WYjUsomFnbZXkjzkeBxLhigA2dEMRaLUREn1Q6TyUT/TrJQTk5OIhQKQSKR0LNwYvIw03OOxWJZX6+IGJ9vMFHE3B8ekml28uRJ2mySL8RiMRwOBwYGBqDRaNDe3i74OQMRReI3ajabUV9fj5KSEgDpfUrTiSHHcRCLxbSRhMQ2kYti8oUy+fyRDBKTnUg+Ll4ikQhlZWVwOp0z7pzi8TgtM8pkMphMJipK89kRyOVy1NXVZS2I6fD7/fQMS6lUory8HFKplJZaa2pqYLPZBHmsudBoNNBqtRgbG6MJ8TNRWFhIy9RyuRwqlQoajYY2Hk0fbTifZxTJro8ILvl3cnJLOmu2SCRChZKEEovF4pQdJXFDyqX71O12pyRxnC8wUZyFWCyGoaEhWK1WSCQSbNy4Ma+lBNIsMjg4mPU4RzaIRCJaAk7ehZLdIRFDYgh8/Phx9PT0IBwO0w8X+XukU3QmeJ6HTqeDXC6Hz+c7yydUKpWisLAQKpWKjooQZ/9c3E2kUilKSkowNTWVVYdnJBKhAqlUKmm3a7alYb1eD51ON6sfaq4kEgnY7XZwHIeioiKa9EEMyX0+H9xut+DvUYVCAaPRiPHx8YydfDwez5ylX4VCQd15TCYTCgsLBfUZFnpkJF9ld7LbTn6M5H8D6YVSJpPBaDSmdLpHo1EaSjwyMgK/35/ilCWTyWg3+FycjwkZABPFtCQSCYyPj2NkZARVVVXYtGkTDh48mDdBjMViGBgYgMPhgFqtRltbW978/9xuNyYmJqBQKOgudHqpFACGhoZw7NgxDA4OZn0hkEql0Ol0SCQSsNlsszZ9RKNR2O32tOeIJAORNBpEo1H4/X54vd6zfhdKpRJGo1GQ5pnkAX2tVguJRAKPxzOnSFdVVSEWi+XNAk6hUECr1WJqagojIyNp/45cLodWq6XNRn6/P+f1yOVy6uSTj/J2KBSC3++nDT4EpVKJqqoqlJSUQK1Wn+XMkylClzplMlneZxSJWCXv6rIRSqlUCr1en9KIR87/SfiB3++nY05kR6lWq8/aSXo8HrZTPF8hF9hkx5aioiJ0dHSkzG4JHUOTnGBRXV2NpqYmao4rNMkWcGVlZdTyLFkMg8EgTpw4gePHj2d9ISWlmkAgAIvFMmd5LRNmalARi8W0NEdKT8PDw3npJCU7RZFIhNLSUir003chDQ0NcLlceXGL0el0EIvFmJiYSGnKSUc4HE67G9fpdLQT1+/3zzpjSXbbk5OTM4qvENTW1sJms521owwGg+jr60NfXx+Af5TCS0tLodfrM3Z+ykc362JYvM0llOQfIL1QSiQSiMViVFZWUgEmlQWv14vx8XH6OSNCOTAwAL/fP6+dYqaxUd/73vfwxhtvIJFIYPv27XjqqacWtbmHieJHuN1u9PX1QS6XY+3atWfN8JEPohBJEzzPw2azob+//6wEC6FjquLxOIaHh2GxWFBfX4/i4mJMTEwgEonQO/Dx8XEcP36cOvFMRyKRQKVSpeQBkuF7iUQCt9tNZ9byIejT4Xmeep2SXSgZbYhEIrBYLHkpnSV3YpaUlCAUCmFqagq1tbVzilW2kBJpIBCYdwNNNBo961xVIpFQoeQ4DoFAAF6vl5ae8ymGKpUKJpMp45QRUrlJrjhotVpUVFSgqKgISqXyrPdtNkbpmZKPC7VYLM7JCDwboSRzvMCZ6wE579dqtSkWbolEAj6fD06nEy+++CL+7//+Dz6fDzabDevWrUNHRwcuuuiijNeYSWzUe++9h3fffZc2cX384x/HW2+9hUsuuSTr10QomCjiH7uo5ubmGcsFZCxjvqKYbJc2m/jOF57nMTk5icHBQTpHSRIkFAoFenp60NXVBbvdjmg0CoVCgfLycip2sVgMkUgEwWAQkUgEgUCAepdyHIfi4mI4nc60Z25qtZqeI0ajUTgcDkFmGHU6HS0fTu8kDYVCdK5RpVKhqKgIoVBo3nN/6QiHw5iYmEBlZSXKy8sRCoVo+Ym8folEgt50iEQiercei8UQjUapPVw8Hkc8HqdnszKZDIWFhbBarXkVplgsBpvNBolEAqPRSNfmcrmg0+mg1+sRCAQEjdwCzvhc+ny+eZsluN3ulGqGQqFAaWkpTCYTtFrtkvZ4TUZIe7d0QunxeNDT00Mdi2bbUYpEIhQWFqKwsBC//OUv8dJLLyESieCTn/wkPvjgA7z33ntZiWImsVEcxyEUCiESiYDneXpGvpgwUcSZM4y5vPbmu4NLN/aQj8cBzlwwenp6oNFo6BwlOTcMBoM03T55ni8T0RKJRDTBe7YzJnLBTcZoNKKwsBAikQjBYBA2my2jFnyRSISKigpEo1FYLJaMyrqBQICuT6PRwGg0IhAIwGq1zlsgVSoVSktLYbfbBR2B4DgOdXV1sNvtCAQCMBqN9OIQjUYRDAbh8/kEcXyRy+UwGAx0LjRZfKe7tZCcPRJpRYQy212TTCZDRUVF3sZGQqEQhoeHMTo6Cr1eD6/XC5lMRhufSDMXEYZcBDMfIpsvz1My32y1WtHa2prStDfXGSVw5nPndrtRWVmJ1atXY/Xq1VmvIZPYqIsuugiXXnopysrKwPM8KGB5HgAAIABJREFUdu7cidbW1qwfS0iYKGZIrmKVrnw52wVlPi4coVAIfX19iEQitHuViGEkEsHRo0dx5MiRrM9FOI6DXq+H2+3OefeSvNME/hGmq1KpEI/H4Xa74XQ6qWip1WoYjUZYrdazdoXZkDzSUFhYCL1eD7/fn/WAu9FohFarhdlsntd60qHRaCCRSKhghMPhGTs3CwsLoVar6WwgcesJBoPweDwzvkfVajW0Wi2CwWDGNxcA6M1IMlKplDb9iMVimtg+E6Q7Np9zlGSkxmq10vXOttNVq9UoKiqC0Wik83vEuWemz18+ZhTzYevm9/tx8uRJGAwGtLe3n9Vpmkkzj9lsxiuvvDKnB+l8Y6NOnTqF7u5u+pnavn073n77bWzZsiWzJ5sHmCgi80zFbEYEkhMsKioqskqwyHaImXTvJUdHAWfe6NFoFCdOnMD777+ftWejWCymwjSflPl08DwPp9OZ0pBDMgWVSiWNUxLyQpRsr6bX66HVauH1emd00OE4DhUVFdRIQci0D+DMjUF1dTUdxs6ESCQy4/uDDHMrlcqU8qzb7YbZbM7ZKWg60WgU0Wg0RbiVSiX0ej3kcjmN6gqFQqitrcXExETeHIRUKhV0Ol3WTUHkZind90ilUhQXF9NsSjIykQ9RFHKnSMzeJycn0dramlXnKLk2iUQi/OEPf8Cjjz6KRx99FFddddWs3zff2Kg//vGP2LRpE+22v/LKK3HgwAEmiksBITMVHQ4H+vr6oNVqs7aBy2anmOy/miy85Eywp6cHnZ2dWXeSkl3c1NRUXqONFAoFCgsLEQgE0p47EsNuhUKBSCSStuszV5LPpAwGA7RaLVwuF5xOJ6RSKSorK+H3+/MybwiAdrIKvXsKBAKQSqU0sDgej0MkEqG6uhoSiYQaQwtNsr0ex3GoqalBYWEh/H4/TCYT9U4lu5FIJEKDnXMRTLJjnpiYyMoKLxOi0SjGx8dhNpuhVqsRi8WooUNTUxMaGhqg1WoFaSoTShT9fj+6u7vpNScXizu73Y7bb78dYrEYf/vb33JK+kkmk9io6upqPP/887jrrrvA8zzeeustfPvb357X484XlpLxEeSgdyZOnz4NnudRXV0949/x+/20jbypqQlqtTrrdTgcDlgsljnr6iTEuKCgAA0NDfTcMJFIoL+/HwcPHpx1Z8DzPB1pIB2liUQCCoUCXq8XYrGYNo4AoI0jpFEkHA4jFAplnUqh1+vpecX0c8e5kEgkMJlMUCqVCIVCsNlsgu1A5HI5bTghxONx+P1++Hw+wToP5XJ5Xs7WiElCLBabszRMOjZdLpdgu0dCTU0N4vF4ViM5SqWS7m6JOxIAGiWWnFFJfkf5KsWKRCIYjUbEYjGMjY3NKnxarRYXXnghysrKcmrs4TgOa9asmdd7i8weTkxMoLW1dc5A4Jl+xr59+/DAAw/g7rvvxvXXXy/I+91ut+P666/H6OgojY0yGAwpsVHxeBzf/OY38fe//x0cx+GKK67A448/Pu/HnoGMnhQTxY+YKz5qcnISgUAgbfRKcpZiU1MTDAZDzuvweDwYGRnBqlWr0v5/MsMVi8XQ3NwMjUZDxXBkZAQHDhzA5OQkHVtIFj1ykSHOOckfeHKxyfYiSeynpFIpfZzpobvEN9br9QrarCCVSmEymaBQKGjzTqaQ3bBEIqEl1Jk+C2TOT6VS0Z18KBSCx+PJSpQrKyvpay8UEokEBoMBdrs9px0gsWMLBAL0fZMLVVVV4DhOcJEFzly0S0tL6XuXiCcR0OQ5Y9LNG41G6W40k/cc2RWNj4/nNIvIcRwaGxvR0NBAb07mQqFQpI2jy5RAIIDu7m4UFBSgvr4+5xDh73//+3A6nXj22WdpRNwyhYliNswlijabDXa7Hc3NzfRriUQCo6OjGB8fFyRLETiz2+zv78eaNWtSvp5sOdfY2AiTyUTFcGhoCN3d3XA6nSmdipmUYcnMndDnPqT0SUp4JpMJYrEYZrN5xhSL+UK8IWUyGYLBYMoFmsz9yeVyGlY83zMikUhEcwflcjmUSiXC4TB8Pl/K+bNKpUJxcbGgmY3ES9RsNgs2UK5UKmEwGODz+WC32zMSk4qKCkgkkqx3/ZnAcRxKS0vh8XjmZQZBxmFkMhmUSiWkUimthIjFYgwNDQleUtZqtWhpaUF5eTmt4qT7O/X19Vn/bJ7nMTY2hvHxcbS0tOQ0YM/zPP7+97/j+9//Pr797W/jpptuyluA8hKCiWI2zCWKLpcL4+PjWLlyJXieh8ViweDgIEpKSlBbWyuYoXE4HEZXVxcdEUlu2KmqqkJlZSVEIhEsFguOHz+OkydP5pxWUVVVBYfDIWiwK3DmgN3lcs14oSHiZLVa82aJBpzp6qypqaEzm0IP2M/12Fqtll6wkt9byTdO5PM315k2+X9k5nF4eDgv7ioEsgsHkLYRiFzshYqpSvfYNptt3kksM1FcXEyTJ8hc7cjIiOCfBeDMDWJtbS1qampgMBio+JSUlKCioiKrnxUMBtHd3Q21Wo2GhoacrjuBQAD33nsv+vv7sXfvXtTU1GT9M85RmChmQywWm3Xn4PP5MDAwgNraWvT29kKlUqGxsVHwlup4PI7Dhw+jo6MDTqcTvb290Gq1aGhoQCgUwokTJ9DV1TWvi1GupdK5IC362eyIjEYjDeAVwhoOOHOxKSgogNVqTenUJPN2brdbkJnFmRCJRKirq6M2WkJRXV0Nu92OWCwGjuNopykZgHY6nSljL0JB8i6J96dKpYLZbBb89SMdrELufqdDmoDGxsbOugkmYx1ms1nw5p1kioqKaJc4yUkkQ/NqtTpttYk4T42NjaG5uTnnkPHOzk7cdtttuPnmm7Fjx47zYXeYDBPFbJhLFN1uNz744AMUFBSgubk5bwkWPM/j3XffhUajQSKRwIoVK3D69Gl0dXVheHh43pFG+SiVymQyGAyGtBeabNDr9VCr1XA4HDmdbVZWViIUCmW0I1Sr1dDr9dSdRohOQpFIhJqaGjozKBQSiQSVlZUZjcUolUo6b0eihVwuV06/b7FYTDP6iFdm8uskk8mohy455yPxYWTnS0r8pEEr3UgJGXsgpfZ8oVarUVhYOGfMFvFadTgcedkJFxUV4XOf+xxqamoQjUbh9Xppqkhy/BMRSrFYjO7ubiiVSjQ2NubkqhUOh7F79250dnZi7969aGpqEvx5nQMwUcwG0lk5nVgshsHBQdhsNsTj8bzOz5DHGhoaQnFxMUZHR9Hb25tThNJ08lUqLSsrw9TUlODnhDqdDhqNBi6Xa9YLk9FohFwuh9vtzlmQpVIpzamzWCxZN8JwHIfa2lqEQiHBy8HELm8+dmsknksmk9HkDIfDcdb7XaPRoLCwEBzH0XPFfOymSewR2SkRo/1AIJC3xywvL4fb7c76fVpaWopwOCzIaBLHcfjYxz6Gyy+/fFa/02ShtFgs8Pl89Lx3rh1lOo4fP45//dd/xXXXXYfbb79dEP/mcxQmitkwXRSJCfHo6Ciqq6tRXl6Ozs5ObN68WfDHJqWRoaEhRKNR9PX10bLY9H+A1DOp6WdR5O48+Q5dJpPRxhtytz7fLlBiE5aPbsPpkAsBuUiQsN1gMChYyTUZcubpcrlmbSAhpbhIJCK4RyhwplzqcDgEuSlKh0ajgV6vp/Z/c40gCAXJUBwfHz9LAEk3LYm+yiSXcTbIjOZ8o6/IkcPw8HBOn52ioiJcd911qK2tzejvh8NhnDx5EnK5HE1NTeB5Pu2OsrCwkO4qpwtlNBrFE088gX379uG5557DhRdemPW6lxlMFLOBuL8AoPFRRqMRK1asoHdW7733nuCi6HA40NPTg2AwmFMXHMdx1HGD4zhEIhEaDTTbBU4qldLSl1QqPavFPbn8lWxYzXEc1Gq14FZnmWAwGFBQUIBYLEZnKKPRKEKhEHw+X9ZOQJmgUChgMBgQDodhNptpeY/M4+WjeUcikaCqqiqvtmgk0De5JEvmSIlZgsPhELTRRa1W03zGbISFnDVKpVJEIhE4nc6MKh46nQ5SqVTQG7fCwkJoNBp6AzsXHMdh8+bNuOKKKzJKwyBNYcPDw2hsbKQVjHSkK71aLBb853/+J1asWIHXX38dn/70p3HfffdlZSCyjGGimA2JRAIOh4MmWDQ2Np6VYCGkKAYCAfT29sJqtWJiYmLOHQ/HcbRUGAwGqRDMp2yYKeQskjh7aLVaOh/pdDrz2gUJnCl9kY7fudapVqshl8shkUio634oFILX681pFySVSulgObnxIDcf5HcgZLmP5ETmYwcM/MNFaGxsLKN1kxBaADRGKNv3m0qlgl6vh9VqFey9SkQdOPPZcDqdKT+7uroaFoslb7tshUIBo9GIsbGxGcvtRqMRn/vc5zLeHUYiEXR3d0MikaCpqSmnSCmn04kf//jHOHDgAHQ6HWw2GwoKCnDjjTfi1ltvzfrnLTOYKGaDx+PBsWPHZk2wINEp85lFjEaj9NzQarXOWJ5Tq9UwGAzQaDR0J6dSqaDVaqFWqxEOh6n7zdTUFD17EAqpVEqtyCYnJ2dtgCgsLIROp4NIJKK71PnOa0okEpSXl8Pr9Qp2TqdUKqFSqSCXy1PMtEnGHHFOIVWDSCQy50WVxO1oNBrI5XJwHEfz60jCeaZUVVXB5XLlZccrFovpLm0+QkHKmzKZDKFQCHa7fcZzOhJHZjab8yZOBJFIRCsJEokEp0+fzsvrOB2JRIKSkhJYrVZaNSC7w8svvzzjHRoZ8Ur2Ls6WkZER7NixA2vWrMFDDz1Eb+qJfWFdXV1OP3cZwUQxG3ieRzgcnvUidujQIaxduzanOzhix9TT0wObzZay65FIJCguLkZpaSlKS0vpSMF0SCOHx+OB2+1GNBqlzREkQ478bCKU08cSZkMikVBHi8nJyZzPl0hTALlwTr+Lnw0SQGu1WvMyMwacEYiioiJqOg6Advklp2rMF5KNqFar6XuGlLeTfydisRjV1dV5K5eSi3a+TBOSKwcejwc+nw/l5eWYnJxcEGECzghRVVUVfd+QmDOZTEY/M/l+/NLSUvA8j0984hNpna/SEYlE0NPTA5FIhObm5pyuLYlEAr/85S/x/PPP46mnnsLFF1+c9c84T2CimA1k1zAbH374IZqbm2nUTKbY7XYcO3YMFosFFosFer2eil9xcTE9xM92d8XzPPx+PzW3JueRRCTJHJvL5aIiSQTT4XAgkUhALBajtLQUIpEIk5OTebmjJ5ZqSqUS0Wg07W6IRPiYzea8lIN5nkdRURFEItGsc3AkQFmhUOTNPBs4I/6FhYUwGo3Ugg8AzfojZ7iRSCTnmxODwYBAIJBXg4RkVCoVtZwjOza/35/3ZqyioiJwHDdrUxQJqCZuRkJDgrxbWloynv2bmprCwMAAjZTLBbPZjJ07d6KmpgaPPvpo3kbFlglMFLNlrrOxrq4u6v6fCSTXzOVyQa1Wo6KiAiUlJSkJ2DPljOUKie0hQun3++mOhQilQqFANBqF1WrF6Ogoenp6MDo6mtcZsWQ4jkspdUmlUrjdboRCIYRCIUFFsaCgAGq1GjabLSdxMJlMUKvVsNvtgnWYqlQqVFRU0B3/XBAbOXKumWxTlvz+SfYGJa5HC4FWq4VKpZox6otUDkj2olDnpVKplI7tZINCoaANLNlUUtLR2NiITZs2ZeUKE41G0dPTA57n0dLSklMTDM/zeO211/DEE0/g4YcfxpVXXinodWSZwkQxW+YSxe7ubpSUlMxp+B2NRnHq1Cm43W7qPpE8JkHmshbqTRyJRFLKrsSVJFko4/E4BgcH0d/fT9eeLxQKBRWFdDux5KFwIgDk7ju5G5YMgk8vCxIzAZ/PJ6gwGI1GaDQaeDyenLw+yfeTmVeh4TgO9fX1ND1Eo9FApVJBLBYjFoshEAjA6XQKNnZhMpnAcVzWZV+yoxSJRPB4PFmL2vRS6XwgZVa5XA6n05lRZUAsFmPVqlXYtGnTrN2h6SCd7StWrEBJSUlOa7ZarbjtttugUqnw1FNPzSuA4DyDiWK2zBUf1d/fD61WO2OpI5FIYGxsDKdPn0ZtbS3Ky8vpaEM8Hl9wMZwJnucRDAbpbtLj8SCRSKCgoIB2P/b09GBsbAxer1ewsF+DwQC9Xo+pqSnBy7TEDJzcfExOTubNNxP4RznO5/PNmrlInHaIIOULjUYDk8k054gIx3HQaDRQKpVULDMZ4Un+/tLS0qxTSWaDNJUBmNUzF8isVDof9Ho9CgsL05ZZFQoF1q1bh40bN9JQ3Ewh88exWAytra057w7feOMNPPjgg7jvvvtw7bXXLvq15ByDiWK2zCWKw8PDkEqlaU18rVYr+vv7YTKZUFdXR0cCyBkRIHypVEjIoPTIyAgcDgedYyTnkg6HA8PDwzh16lRW52wkvV4sFuetnGcymWiXbPLjlpSU0LDdfA6lFxQUwGAwIBgM0vglk8kEnU4Hi8WS92aTmpoaBAKBeT0OEUuVSgWRSIRoNErFMh6P0zT6dGHQQpOcbel0Oqmji8lkymvo9XSUSiWNF2tqasKaNWtyEjObzYb+/n7U1taitLQ0p2uAy+XCnXfeCb/fj1/84hc57zLPc5goZstcSRljY2OIx+Mp5wc+nw+9vb30g6NUKs8pMSTY7Xb09/ejuLgYNTU1EIvFiEajdDCYWGQpFArEYjHY7XYaX5PuNSNhuqQRKB+UlZVl1MhBunvJAH6+EIlENNcuFovlXUAkEgnq6+sFjaSaDrGHi0aj1P5tIdNGlEolSkpKaE6iw+HI+1wsQSaT4aKLLsLmzZtzskaLxWLo6+tDJBJBa2trTuEBPM/jb3/7G37wgx/gjjvuwI033ni+mXgLCRPFbMkkaNjv96O+vh6RSASnTp2Cx+NZEueGuRIIBNDX1weRSJTWsCAZMraSXHYl2Y12ux0TExPUR3RqaiovOyQicE6nM6c2e3KOmmvjTTqkUilqamrg9/vPWhOx4EokEnC73YI165B5VSEDiwkSiQR6vR5erzdtaZi4/EilUupXKnTHMDGqmG4STnIxNRoNwuFwXh5bJBKhpaUFDQ0NdI6VmIkTW7W5RNJut6Ovrw81NTU556z6fD7cc889GB4ext69e1FVVZXrU2KcgYlitsyVlGG32zE1NQWlUnlWsPBSOzeci3g8jqGhIdjtdjQ2NuZ8WM/zPHw+H22YsNlsiEajtDmGCGkgEIDP56NzgNkKJnEQsVgsgs3bFRcXQyqVYnx8PCcBJx3Fdrs944YPtVpNzSHcbndO54z19fVwOp2CN+uQ6K+JiYmsXg+JREJFLBqN0vdAtnAch7KyMoRCoVnPaZMhZV3i7zvfm47m5mZs27YNRqORfo2MPpGqCTmDJzPCRChJhaC/vx+hUAitra1QKBQ5reO9997Dd7/7Xdx66634+te/znaHwsBEMVtmE0We5zEyMoKBgQHU1NSgrq6OuqKcS6VSYpc2NDSEyspKVFRUCP6Bi8fjtOTq8XjoWAjpdNVqteA4jgokEctk0ST/Tc668nkuSC6sZJh/rs+EwWBAUVERLBbLvNdEXIpIJ+ZspWClUonKysqMBSMTyK7Q5XIJNk9IRm7UajXi8ficOY/k7M5qtc67OUqtVsNoNILjOLhcrozzJcvLy7F9+3ZUV1dn9PdJ2gh5jxMbwWg0iqKiIlRVVaGgoCDrz1YoFMK//du/4YMPPsDevXvR0NCQ1fdnyunTp/GVr3wFFosFHMfh1ltvxa5du+BwOPD5z38ew8PDqK2txWuvvZZzduMShIlitswkil6vF729vXTns379+nNODIEzz4MkcDQ0NCyoSXA4HE4RSjIWQoQy2csymVgshrGxMYyOjmJ0dBRjY2N5bVwhyRFOp/Oss7OysjKoVCpYLJa8BRQrFAp6EUo+k6yoqKA7lmxIvihzHAeRSASxWEwt6YTKkpwL8nsm5g2hUIimYeQzR5HELcXjcdhstrOeq06nw6WXXoqVK1fm/PmNx+Po7++H3+9HVVUVfa/7fD5wHHdWiPBMQvnhhx9i165d+MIXvoDvfOc7EIvFOa0nE8xmM8xmM9atWwev14v169fjT3/6E1566SUYDAZ8//vfx8MPP0y9VJcJTBSzZXp8VCQSQX9/P3w+H3WyOXbsGNatW0fPD88FMYxGoxgYGIDP50NTU1PG5gP5hOd5BAKBFKEks3VarZaemU2/gCQSCZjNZoyOjmJgYACnT5/Om68mceGJx+MLOgwPnBGzgoICaDQa2mRCbsKSb8gSiUTK/yf/Tf48nYKCAuh0OtjtdohEIigUCigUCpo4kuloRq4Q0SdNW9FoFFNTU3m7yUiG+L8SZ6VVq1Zh48aN8xIfl8uFnp4eWnWZfi0gZhqk7Orz+WiIcDQaRSwWQ0tLC5544gn89a9/xfPPP4+VK1fO96lmzdVXX42dO3di586d2L9/P8rKymA2m3HJJZegt7d3wdeTJ5goZgsRxUQigZGREUxMTGDFihW0jToej+Ptt99GQ0MDdDrdrE0pSwGe5zE2NoaxsbF5tYMvFIlEgrrxJF9AksuupPv11KlTCAQCaGpqQigUwsjICN1NzsfnkviiKhQKanhNREIqlVIRISbtRLST0+WJM0+mKBQKFBQUgOM4eL1e6o8qpFDIZDLU1NRkVPJVKpVQKBSQSCSIxWLUbSgXeJ6HVqtFIpGgO6h0j0c6TKempvKa+iKRSNDR0YGtW7fO6/Mbj8cxMDAAr9eLtra2rH5WLBaDx+PBwYMH8fTTT6O3txcKhQLXXHMNNm7ciI997GML2lQzPDyMrVu34sSJE6iurqbnsjzP09L6MoGJYrbE43GMj49jYGAAJSUlqK2tPevckDjOezwehEKhlBIgaVRYCjidTvT390Ov19O5yXMRMhaS7O8ai8VgNBpRUVEBrVZ7lomyy+VKEcnZzsqICMrlcoTDYcHcZjiOo+JCnHlIViXP8xCLxTQkOZ8mAwBQV1dHz2hzRS6X09xOMtM607gJ6RAlfrrZCKpcLqem9BaLRbCyKsdxuPDCC7Ft2zbodLp5/Sy3243u7m6Ul5ejqqoqpxvNeDyOn/70p/j973+PZ599FnV1dThy5Ajef/991NXV4YYbbpjXGjPF5/Ph4osvxt13341rrrkGOp0uRQTJUcIygYlittjtdgwNDaGxsREKhWLOc8N0zjA8z1NnGFICXMjdWSgUQn9/P2KxWE7m5UsVcq6r0WhQUVFBja7dbjfi8XhKWsj0Bge/34/R0VGMjIzQ4W+pVEp3gvn2fCXen9FoNCXjj8ROcRxH329Op1OwcjAxNs+X+4tEIoFaraYdlqTKIlSHsEwmo9WNqampnMu69fX1uOyyy1BWVjav9SQSCQwMDMDtdqOtrS3nz9bg4CB27NiBjo4O/PCHP8y5Q3W+RKNRXHXVVbj88stx2223ATjTfcvKp0wUKSRHL3nWMNtzw5kMuYlIarXavDS4xONxjI6OwmKxoKGhIWtPxqVKLBbDwMAAPB4PWlpa0qYApOsE5DiONjcQw+rk32FyukjyTU3y720+6PV6qNVq+Hw+WK3WjEuhHMdBp9NRYQ+Hw3C5XFkNrBPD8Uw6aeeLWCyGRqOBw+FAKBSCTqdDPB6Hy+US9LGlUinKysogEokytgksKyvDZZddhvr6+nk/vsfjQXd3N0pLS1FdXZ3TjW4ikcALL7yAl156CXv27MGWLVvmva5c4XkeN910EwwGA5588kn69e9+97swGo200cbhcOCRRx5ZtHUKDBPFbCEzdULPG04feI9Go3ReLd3OJts122w2DAwM0A/scphpIv6lw8PDqK6upj6ymULObYjQBQKBlJuTwsLCWR1GyPfPJJrk90jgOA4mkwlSqRR2u13Q/L5kgZdIJPT9NH03JhaLUVdXB5vNlndrOaVSCa1Wi/Hx8bTlUVI6Jp3GQiKRSFBWVgaxWJw25UKn02Hbtm248MIL5/35TSQSGBwchNPpRFtbG9RqdU4/Z3x8HDt27EBDQwMeffTRnH+OULzzzjvYsmULVq1aRa8Xu3fvRkdHB66//nqMjo6ipqYGr7322nIyHGeimC2/+c1v8Kc//Qnt7e3YuHEjVq1alZddHWmtd7lcKTub5N0k6QicDb/fj97eXshkMjQ2NuZkI7UUIdZ5KpUKDQ0NOQWvpoOICRG3SCRCnUqIUGZzJkxKuE6nE319fejq6lowCzIAtExPzivFYnHeBbGgoAAKhQKnT5/OqOxMUihCoVBeyrhisRhlZWWQSqXw+Xzo6OhAR0eHIGfoXq8X3d3d1Pow193hq6++ij179uCxxx7D9u3bl3Sz2zKHiWK2RKNRHDt2DAcPHkRnZydOnDgBtVqN9vZ2bNiwARs3bsx6x5Ip03cmpGVdp9PRizb5oMdiMQwODsLlcqGpqWnejQNLBRJf5XQ60dzcTJ1f8gUZCyFCmXwmTF5zjUaT8e+buJl0dXWht7d3QQSyqKgIarU6xf9UJpPRsz4imORoIBQKIRAIZN3hSXYLY2NjOZdFyQ2f2WwWzJUIOGPd97GPfQwdHR2C3BgmEgkMDw/DZrOhra0t60QMwtTUFHbt2gWdTocnn3xyOQ3Bn6swUZwvPM/D4XCgs7MTBw4cQGdnJ8xmMxoaGrBhwwZs2LABa9euhVKpFFwoeZ5HKBRKKdfF43HatVhRUYG6urplUyq1Wq0YGBhAZWUlKisrF+1uOh6Pw+fzpZwtSiSSs0Ka51pfNBpFf38/jhw5glOnTgnezFNQUIDi4mKMj4/nJFIqlQpqtRpyuZyGFcfjcYTDYQSDQSpaJSUlCAQCgs5oisVilJeX01SRXCkqKsLWrVuxdu1awbqrfT4fTp48CZPJhJqampw+XzzP4y9/+Qt2796NBx98EFdffTXbHS4NmCjmg3g8jt7eXhw4cACHDh3CBx98AABYt26iEngUAAAa5ElEQVQdLbvW19cLLlZut5vOMxUUFNAWe4lEklJ2PddKqIFAIKUEvJAuO5kSjUZTbk5CoRCUSmWKUE4v8UYiEfT19SEej2PFihUYHR1FV1cXTU3IFblcjqqqKpjN5rwO2Wu1Wuj1eup6k6+0D4PBAI1Gk5VTkclkwubNm7F+/XrBSutkNtlqtaK1tTVtQ1cmOJ1O3HHHHYjFYvj5z38Ok8kkyPoYgsBEcSEghtiHDx+mu8nBwUFUVFTQ3WR7ezv1+8wW4qoTCoXQ3Nx8ViknEomkNIOQc7LkJp6lMjuZTDwepyWq5ubmc6oEPNMunoyFRCIRTE1NoaGh4axAaiKWRCAzHb8QiUSora2Fw+EQtPSYjtLSUrpjBM40+hQXFyMYDOa8M50L0l06W2hzfX09Nm7cCIPBkDInmVzuns1GbSZ8Ph+6u7thMBhyrr7wPI8333wT99xzD+6880588YtfZLvDpQcTxcUikUhgdHQUBw4cwMGDB/H+++8jGAxi1apVVCjb2tpmLfkkEgmcPn2auuoUFxdn9CFLdvQnF2zSvUh2NdPHExYaUiotKytDVVXVsigBJxIJWK1WnDp1inqMkjnEmV73SCSC3t5edHV1ob+/f0aBrK6upiKcb2pra2G1Wmcs9yqVSuj1elitVsEMxKdjMplSmnlWrlyJSy65JG24d7KNGil3i8XilHGcmY43iMm/xWJBa2trzvaHXq8Xd999NyYmJvD888+nXSdjScBEcSkRDofx4Ycf4uDBgzh48CC6u7uh0+moSG7YsIEmxb/99tuQSqUwmUzUVWc+JKdWkPEEuVyeUnYVqgw1G8FgMCW7cbGGloWG7HrtdntKg1By85TH46GvO7lYJ8+shsNh9PT04MSJE9R8oaSkBDKZTNBUjJkgO9GJiYmMv4e41oyOjgre8SqTyWiDW7Yzt8nh2NNfd/Lax2IxnDx5Enq9HitWrMh5d/jOO+/ge9/7Hnbs2IFbbrllWdzgLWOYKC5leJ7H1NQUDh48SM8nybC1TqfDAw88gI0bN+ZNOJLLf8muMORirdFoBPuAk/Mai8WCpqam5TT3BIfDgb6+vox3vaFQKEUo05W7ibfrwMAAhoaGBJ15TIdCoYDJZILVas3p+0mwtMfjgdlsntda9Ho9Ojo6sH79ekHf+8njOBaLBaFQCFqtFkajkYplNjeGwWAQDzzwAE6cOIEXXngBdXV1gq11OjfffDNef/11FBcX48SJEwCAo0eP4hvf+AZCoRAkEgl+/vOfY+PGjXlbwzKBieK5QjQaxYMPPoj//u//xte//nXE43EcPHgQx48fh1Qqxfr16+luMteOuLlIJBIpXZfJZtzJs5PZYrfb0d/fj5KSkrytfTEgZ4PETi9Xc+np5W6v13uWVWAoFMLw8DCGhoYwPDycszl3OgwGA8RisWCNNDqdDgqFAmNjYxlnGQJn/Fk3bdqElpaWvL1HAoEATp48Ca1Wi7q6OnoeT3aU8Xic3qAkBwdP5/Dhw/jOd76DG2+8Ed/61rfyfmb/97//HRqNBl/5yleoKF522WX4zne+gyuvvBL/9V//hUceeQT79+/P6zqWARmJ4rnpEr3MkEgkWLVqFe699156zvj1r38dPM/D7Xbj/fffx4EDB/Db3/4WIyMjqK2tpXOT69aty2qWbibI+VdhYSF16E/uuhwfH0/JQJxr2D0UCqGvrw88z2P16tVLPlEkU3ieh9lsxsjISFZnvTNBQpQ1Gg3Ky8sBpFoFDg0N0S7jNWvWYMuWLQgGg5iYmMDQ0BBOnz6dcxdqVVVVVkG8mUDMpOVyOSorKxEKhXD69Om0zTkSiQQXXnghNm3aNG9f0tkgaTHj4+NoaWmhTV0SiQQqlYo+NrEL9Hg8KR23EokEb731FjZs2IA333wTBw4cwCuvvILW1ta8rTmZrVu3Ynh4OOVrHMfRCoLb7abvHcb8YTvFcwxiSkyaeD744ANEo1GsXr2a7iabm5vzcvc6UwYiyegrLCyEUqnE2NgYnedcLh6swBkHoZ6eHqjVajQ0NCxo8kgkEkk5Fw6Hw1AqldBoNPD7/bBarRgZGYHZbM6oO7S+vh7j4+MLsHJQ1yCLxQKXy4WCggJs3LgRGzZsyLvdWTAYxMmTJ6HRaNDQ0JD15yIej8NsNuPpp5/G22+/jampKdTV1WHDhg3YsmULrr322jytPJXh4WFcddVVdKfY3d2Nyy+/nPo0v/fee6ipqVmQtZzDsPLp+UIgEMCRI0eoE09fXx+Ki4vp3GR7ezuMRmNeOk6TdzVWqxVutxtyuRwlJSXQ6XR5M0BfSBKJBIaGhs5qpFlMkhNakst/crkcfr8fNpsN4+PjcDgcKd8nlUpRUVExr6H5XCktLUV7ezuampryXnLkeR7j4+MYGxtDc3Nzzm4ysVgMe/bswV/+8hc8++yzWLt2LdxuN44cOYKJiQnceOONAq88PdNF8Vvf+hYuvvhiXHvttXjttdfw3HPP4c0331yQtZzDMFE8X+F5HhMTE3Q32dnZCY/Hg7a2Nlp2veCCCwQTK3K+Fo1G6S41uYknGo2mNPHMxwB9oXE6nejt7T0nzNaTz4XJHF8kEkEgEIDD4YDH44FEIlnQfDyO41BfX4/29vYFC84NhUI4efIkVCoVGhsbcxbg/v5+7Ny5Ex//+Mdx//33L6oxxnRR1Gq1cLlcNJ9Tq9XmvSFrGcDOFM9XOI5DRUUFrrvuOlx33XUAzpwPHj9+HAcOHMCzzz6LEydOQKVS0d1kLr6u5KxmbGwM9fX1MJlM9PuLi4vp4DoxOHC73RgbG4PX64VIJMraAH0hiUaj1H3mXDkTTT4XJkSj0ZQoM4/HQ3eY8Xgc8XgcDodDcJ9WqVSKlStXor29fcE8P5PPe5ubm3Puco7H49i7dy9efvll/PSnP8XmzZsFXun8KS8vx1tvvYVLLrkEf/3rX9HY2LjYS1o2sJ3iecp8fV2J7RyZ88r2bjwWi9GLtMvlotZpyU08C3lmR0iOrBKikWYpQQzXHQ4HSktLafdlNBqFWCxGIpFAOByGz+eD3W6H3W7PuolHrVZj7dq1WLNmzYLeSIRCIXR3d0OhUKCxsTHn987p06fxzW9+E21tbfjxj3+8JEK6b7jhBuzfvx82mw0lJSV44IEH0NzcjF27diEWi0GhUODnP/851q9fv9hLXeqw8ikjOxKJBPV17ezsTOvrqtFo8MQTT+Bzn/vcvPLlpjOTdVryaIIQXbazEQgE0NPTA6VSKWhk1VKAlIHLy8tRVVWV8jqSsRDy2ifbp4nFYkQiEXi9XtjtdthsNjgcjrNSNoqKitDe3o7W1tYFvZlJvolpamqC0WjM6eckEgm88sor+MUvfoGf/OQn2LZt27K5GWJQmCgy5keyr+u7776L3//+9xgZGUkpuc7H13UuEolESukvXwboJCrIarWecz6sc0GMAAKBAFpbWzPevSU3UJHXXiaT0fk94pJkt9tpYstCEw6H0d3dDalUiqamppxvYiYnJ/Gtb30LxcXFeOKJJ5ZEIxUjLzBRZAhDJBLB5ZdfjrVr1+Lee++Fy+VK6+tKxHIuX9f5rkVIA3QSEEyCZJdyI0222Gw29Pf3o7q6WpAc0ORhdzIWolKpUvxdF2qXODk5iaGhITQ2NuY89sPzPP7whz/gkUcewe7du3HVVVex3eHyhokiQzjMZvOMA9bhcBhHjx6lQjmbr6vQpCv9JRugz2QITfIOQ6EQWlpalsTZkVAkx1a1tLTkrWsyeSyEiGUikaAl78LCQkHtAoEzz62npwcikQjNzc057w7tdjtuv/12iMViPP3008tqnpYxI0wUGYtDsq8rGQmx2WxoamqiIyGrV6/Om68rMeImO5pAIACFQkGFMhwOY3R0FHV1dXkT68WAvO6Dg4NYsWIFSkpKFnwNpORNXntiF5h8k5Jrp7HFYsHg4CDq6+vPiuTKFJ7nsW/fPtx///24++678fnPf37Z/P4Zc8JEkbF0IKkEZDeZ7OtKyq75Kl/yPI9wOAyr1Yrh4WEkEgnIZLKzmnjO5dIpSdkQi8Xz2kHlg+TUCrfbjWAwmHKTMldKC4nYAoDm5uac52s9Hg/uuusu2Gw2PPfcc3m1lmMsSZgoLiVOnz6Nr3zlK7BYLOA4Drfeeit27dq12MtaNKb7unZ2dubN15WkdExNTaGpqQl6vT5vBugLDTFqGB0dndf52kJCblKSy66xWCytGTfJqJzPzpfnebz99tu48847sWvXLnz1q189p2+AGDnDRHEpYTabYTabsW7dOni9Xqxfvx5/+tOf0NbWtthLWzIQX1dSdj1y5AgikQjWrFmTs6+ry+VCb28vzaac7WKYbICe3EiSiQH6YkBGSFQq1YJ7sQoN6XRO9tUlsUjV1dUwGo05hWMHAgHcd9996O3txQsvvJB3f9B0MU8A8PTTT+NnP/sZxGIxPv3pT+ORRx7J6zoYaWGiuJS5+uqrsXPnTmzfvn2xl7KkmcnXdf369dRUOp2vazQaxalTpxAMBnNupCEG6Mn+otMN0NVq9YKfSfE8j9HRUZjN5pTUh+UC6ZqtqamBQqGgrz0ZCyE3KHON5Bw6dAi33XYbvva1r2HHjh0LsjtMF/P0t7/9DQ899BDeeOMNyOVyTE1N5XwmypgXTBSXKsPDw9i6dStOnDiRYsnFmJu5fF3b29tx9OhRnDp1Crt27UJpaamgojXT/F5y2TWfBug+nw/d3d3Q6/Woq6tbUjvX+UKs9aLRKFpbW9MKXjgcTtlNJu/mg8EgysrKoFQqsXv3bnR2duL5559Hc3Pzgj6P6T6l119/PW699VZ88pOfXNB1MM6CieJSxOfz4eKLL8bdd9+Na665ZrGXsywgvq5vvPEGnnvuORQWFqKoqAhr167N2dc1G5LPx/JlgE4MBmw2G1pbW1FQUCDQ6pcGdrsdfX19qK2tzepGJjnO7Ne//jV+/etfw+FwoLq6Gv/8z/+MzZs353VuNh3TRXHNmjW4+uqrsW/fPigUCjz22GPYsGHDgq2HQWGG4EuNaDSKa6+9Fl/60peYIAqIVCoFz/P485//jF/96lfYunVriq/rf/zHf2BiYgINDQ1ob2/Hhg0bsG7duhl9XbNFLpenGKCTsNpkA/T5jCW43W709PTQOLDl1CQSi8XovOjatWuzbm7iOA5qtRoymQyJRAJarRYvv/wyEokEOjs78eijj+LKK6/EF7/4xTw9g7mJxWJwOBzU7OL666/H4OAgGwVZorCd4gLB8zxuuukmGAwGPPnkk4u9nGVHLBajeYLpmMvXdcOGDWhoaMib4JCxBLKbzMQAPR6PY2BgAB6PB62trXkP5F1oHA4H+vr6UFVVNa+dfG9vL3bu3IlLL70U995776Lnd07fKV5xxRW48847cemllwI4E/B88OBBmEymxVzm+Qgrny4l3nnnHWzZsgWrVq2iF97du3fjU5/61CKv7PyEOOEcPnyYCuWpU6dQUVFBG3jy6etKDNBdLhcVy2Q3GI7jMDo6isrKSlRWVi6rXUU8Hkd/fz8CgQDa2tpyHn2Jx+N45pln8Oqrr+IXv/gFNm7cKPBKc2O6KD7zzDOYmJjAD3/4Q/T19WHbtm0YHR1dVr/TcwQmigxGNiQSCYyOjtImnsOHDyMQCCyYr2sikYDT6cTAwAAdR5jexLOYQbdCQNI6KisrUVFRkbMwjIyMYMeOHVi9ejV27969ZPIu08U8ffnLX8bNN9+Mo0ePQiaT4bHHHsMnPvGJxV7q+QgTRUb2xONxtLe3o6KiAq+//vpiL2fRWUhfVzKontxsIrQB+mIRj8dx6tQp+Hw+tLW15SxiiUQCv/zlL/Hcc8/hySefpCVJBiMDmCgysufxxx/H4cOH4fF4mCimgfiLJoczk8ipXH1diY0Zz/NoaWmZ9UwsVwP0xcTlcqGnpwcVFRXzKgWbzWbs3LkTVVVV+MlPfrLsOnAZeYeJIiM7xsbGcNNNN+Huu+/G448/zkQxQ5J9XTs7O3Hs2DFIpVKsW7eOCmU6X9fkgNz5mFwTA3Qyu5dsgE5MBhbDCzUej2NwcBButxttbW05J5HwPI/f/va3ePzxx/Hwww/jyiuvXFKizzhnYKLIyI7rrrsOd911F7xeLx577DEmijkyl6/rhg0bYDAY8Mgjj+B73/seWltbBRWt6d6ibrcb8Xg8ZXYy3wboZIykrKwMVVVVOYuY1WrFbbfdBqVSiT179sBgMAi8UsZ5BJtTZGQO8Wtcv3499u/fv9jLOafhOA46nQ7bt2+nNn6JRAKDg4N499138eMf/xhdXV1YuXIlnnvuuZx9XWd7fIVCAYVCQU20kw3QR0dH82aATp6n0+nEBRdckPMYCc/zeOONN/Dggw/ivvvuw7XXXst2h4wFge0UGQCAu+66Cy+//DIkEglCoRA8Hg+uueYavPLKK4u9tGUDz/P47Gc/i/r6ejz44IMAgCNHjqCzsxOdnZ3UuJx0us7k6yoUQhugezwedHd3o6SkBDU1NTmv2+Vy4c4774TX68Wzzz67KLmQjGUJK58ycmP//v2sfJonHA7HjCXA6b6uhw4doudxZDe5atWqvA2nJxugk/NJAClNPOmSKhKJBIaGhuBwONDa2gqNRpPz4+/fvx933XUXbr/9dnz5y19eVu49jEWHiSIjN5goLh2i0Si6urqoUHZ1dUGtVtPdZL59XePxeIoTTyAQgFwup0IpFotx6tQpmEymeYVE+/1+3HPPPRgaGsLevXtRVVUl8DP5BzPFOwHAT37yE9xxxx2wWq3nRDYlIyuYKDIYyw2e5+FwOHDo0CHaxDMxMYH6+nq6mxTS1zUdxInn9OnT8Hq9KSKZiwH6gQMHcMcdd+Bf/uVf8I1vfCPvu8N08U7AmSDwW265BT09PThy5AgTxeUHE0XG8sPlcuGWW27BiRMnwHEcXnzxRVx00UWLvaxFZbqv64cffgie5/Pm60riqwwGA+rq6gDgrNlJkUh0VhPPdJEOhUJ46KGHcPjwYezduxeNjY2CrC8TpluxAWe6r++55x5cffXVOHz4MBPF5QfrPmUsP3bt2oUrrrgCv/vd7xCJRBAIBBZ7SYuOSCRCa2srWltbcfPNN5/l63r//fdjYGAA5eXl8/J15XkeIyMjsFgsaGtrSxmeLygoQEFBASorKwGkGqCbzWZqgP7hhx+iqKgIOp0OP/jBD/CFL3wBf/3rXxfdlefPf/4zKioqsHr16kVdB2PxYTtFxjmD2+3GmjVrWOxODhBf14MHD9IIo0AggAsuuIAaDMzm6+r3+3Hy5Eno9XqsWLEi610nz/MIBoP44x//iFdffRVdXV0wmUzYvHkzOjo68KlPfQrl5eVCPNWMSN4pBgIBXHrppfif//kfaLVa1NbWsp3i8oTtFBnLi6GhIZhMJnzta1/DsWPHsH79ejz11FPLLlIpH4hEItTW1qK2thZf+MIXAKT6uj755JPo6emBVqulO8mNGzeiqKgITz75JDZs2IA1a9ZAq9Xm9Pgcx2F4eBgvvPACrrjiCuzbtw+JRAJHjx5FZ2cnLBbLgopiMgMDAxgaGqK7xLGxMaxbtw6HDh1CaWnpoqyJsXiwnSLjnOHw4cPYtGkT3n33XXR0dGDXrl0oLCykM3+M+THd13X//v04deoU2tracPnll+Oiiy7K2tcVONPB+rOf/Qy/+93v8Mwzz6C9vT1PzyBz0p0pEthOcdmS0U6RDQExzhlItmBHRweAM40RJCyYMX84jkNJSQn+6Z/+CY2NjYhEIvjjH/+Ip59+GkVFRXj55Zexfft2fOITn8Add9yB3/zmNxgaGkIikZjxZw4NDeGqq66C3W7HO++8syQE8YYbbsBFF11EI6xeeOGFxV4SYwnBdoqMc4otW7Zg7969aG5uxv333w+/349HH310sZe17Hj//fdxwQUXnBXxxPM8PB4PHQk5dOgQRkZGUFNTQ0uu69evh1qtxosvvogXX3wRe/bswdatWxfpmTAYFDaSwVh+HD16FLfccgsikQhWrFiBf//3f4der1/sZZ3XEL9TYjBw5MgRDAwM4DOf+Qz27NmTs8MNgyEwTBQZDMbiYLPZYDAYmE0bYynBzhQZjMXgiSeewMqVK3HBBRfghhtuQCgUWuwlLThFRUVMEBnnJOxdy2AIyPj4OPbs2YPDhw/jxIkTiMfjePXVVxd7WQwGI0OYKDIYAhOLxRAMBhGLxRAIBBZt/o7BYGQPE0UGQ0AqKipwxx13oLq6GmVlZdBqtbjssssWe1kMBiNDmCgyGALidDrx5z//GUNDQ5iYmIDf72dBzQzGOQQTRQZDQN58803U1dXBZDJBKpXimmuuwXvvvbfYyzrnuPnmm1FcXIwLLriAfu273/0uWlpacOGFF+Kzn/0sXC7XIq6QsVxhoshgCEh1dTUOHjyIQCAAnufxv//7v2htbV3sZZ1zfPWrX8W+fftSvrZ9+3acOHECx48fR1NTE370ox8t0uoYyxkmigyGgHR0dOC6667DunXrsGrVKiQSCdx6662Lvaxzjq1bt8JgMKR87bLLLqMpHps2bcLY2NhiLI2xzGHD+wwGY0kym2n3Zz7zGXz+85/HjTfeuAgrY5yjsOF9BoOx/HjooYcgkUjwpS99abGXwliGMFFkMM4j0jWwOBwObN++HY2Njdi+fTucTucirnB2XnrpJbz++uv41a9+xYKmGXmBiSKDcR6RroHl4YcfxrZt29Df349t27bh4YcfXqTVzc6+ffvwyCOP4C9/+QtUKtViL4exTGFnigzGecb0s7rm5mbs378fZWVlMJvNuOSSS9Db27uoa7zhhhuwf/9+2Gw2lJSU4IEHHsCPfvQjhMNhGI1GAGeabZ555plFXSfjnIKlZDAYjLOZLoo6nY7O/PE8D71ez2YAGcsR1mjDYDCyg+M4dlbHOK9hoshgnOeUlJTAbDYDAMxmM4qLixd5RQzG4pFt+ZTBYJzjcBxXC+B1nucv+OjPjwKw8zz/MMdx3wdg4Hn+e4u4RAZj0WCiyGCcR3Ac9/8AXAKgCIAFwH0A/gTgNQDVAEYAXM/zvGOx1shgLCZMFBkMBoPB+Ah2pshgMBgMxkcwUWQwGAwG4yOYKDIYDAaD8RFMFBkMBoPB+AgmigwGg8FgfAQTRQaDwWAwPoKJIoPBYDAYH8FEkcFgMBiMj/j/QcpF88+QfaUAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "draw_value(V, useable_ace = True, A = A) # 绘制状态价值图\n",
    "draw_value(V, useable_ace = False, A = A) # 绘制状态价值图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2/2 [00:00<00:00, 885.90it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "========= 开始新一局 =========\n",
      "发了2张牌(['Q', 'Q'])给玩家;玩家现在的牌:['Q', 'Q']\n",
      "发了2张牌(['K', '2'])给庄家;庄家现在的牌:['K', '2']\n",
      "玩家选择:停止叫牌;\n",
      "庄家选择:继续叫牌;发了1张牌(['4'])给庄家;庄家现在的牌:['K', '2', '4']\n",
      "庄家选择:继续叫牌;发了1张牌(['10'])给庄家;庄家现在的牌:['K', '2', '4', '10']\n",
      "庄家选择:停止叫牌;\n",
      "双方均了停止叫牌;\n",
      "玩家现在的牌:['Q', 'Q']\n",
      "庄家现在的牌:['K', '2', '4', '10']\n",
      "玩家赢了!玩家20点,庄家26点\n",
      "========= 本局结束 ==========\n",
      "========= 开始新一局 =========\n",
      "发了2张牌(['9', '4'])给玩家;玩家现在的牌:['9', '4']\n",
      "发了2张牌(['J', 'A'])给庄家;庄家现在的牌:['J', 'A']\n",
      "玩家选择:继续叫牌;发了1张牌(['5'])给玩家;玩家现在的牌:['9', '4', '5']\n",
      "玩家选择:继续叫牌;发了1张牌(['4'])给玩家;玩家现在的牌:['9', '4', '5', '4']\n",
      "玩家选择:停止叫牌;玩家爆点22输了，得分:-1\n",
      "========= 本局结束 ==========\n",
      "共玩了2局，玩家赢1局，和0局，输1局，胜率：0.50,不输率:0.50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# 观察几局对局信息\n",
    "display = True\n",
    "player.display, dealer.display, arena.display = display, display, display\n",
    "arena.play_games(dealer, player, num =2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 蒙特卡洛控制"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils import epsilon_greedy_policy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MC_Player(Player):\n",
    "    def __init__(self, name = \"\", A = None, display = False):\n",
    "        super(MC_Player, self).__init__(name, A, display)\n",
    "        self.Q = {}   # 某一状态行为对的价值，策略迭代时使用\n",
    "        self.Nsa = {} # Nsa的计数：某一状态行为对出现的次数\n",
    "        self.total_learning_times = 0\n",
    "        self.policy = self.greedy_policy\n",
    "        self.learning_method = self.learn_Q\n",
    "    \n",
    "    def learn_Q(self, episode, r): # 从状态序列来学习Q值\n",
    "        '''从Episode学习\n",
    "        '''\n",
    "        #for episode, r in episodes:\n",
    "        for s, a in episode:\n",
    "            nsa = get_dict(self.Nsa, s, a)\n",
    "            set_dict(self.Nsa, nsa+1, s, a)\n",
    "            q = get_dict(self.Q, s,a)\n",
    "            set_dict(self.Q, q+(r-q)/(nsa+1), s, a)\n",
    "        self.total_learning_times += 1\n",
    "    \n",
    "    def reset_memory(self):\n",
    "        '''忘记既往学习经历\n",
    "        '''\n",
    "        self.Q.clear()\n",
    "        self.Nsa.clear()\n",
    "        self.total_learning_times = 0\n",
    "\n",
    "    \n",
    "    def greedy_policy(self, dealer, epsilon = None):\n",
    "        player_points, _ = self.get_points()\n",
    "        if player_points >= 21:\n",
    "            return self.A[1]\n",
    "        if player_points < 12:\n",
    "            return self.A[0]\n",
    "        else:\n",
    "            A, Q = self.A, self.Q\n",
    "            s = self.get_state_name(dealer)\n",
    "            if epsilon is None:\n",
    "                #epsilon = 1.0/(self.total_learning_times+1)\n",
    "                #epsilon = 1.0/(1 + math.sqrt(1 + player.total_learning_times))\n",
    "                epsilon = 1.0/(1 + 4 * math.log10(1+player.total_learning_times))\n",
    "            return epsilon_greedy_policy(A, s, Q, epsilon)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "display = False\n",
    "player = MC_Player(A = A, display = display)\n",
    "dealer = Dealer(A = A, display = display)\n",
    "# 创建一个场景\n",
    "arena = Arena(A = A, display=display)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2000000/2000000 [04:11<00:00, 7951.43it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "共玩了2000000局，玩家赢853503局，和179007局，输967490局，胜率：0.43,不输率:0.52\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "arena.play_games(dealer = dealer, player = player,num = 2000000, show_statistic = True)\n",
    "#print(player.Q)\n",
    "#print(player.A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_policy(policy, A, Q, epsilon, useable_ace = False):\n",
    "    def value_of(a):\n",
    "        if a == A[0]:\n",
    "            return 0\n",
    "        else:\n",
    "            return 1\n",
    "    rows, cols = 11, 10\n",
    "    useable_ace = bool(useable_ace)\n",
    "    Z = np.zeros((rows, cols))\n",
    "    dealer_first_card = np.arange(1, 12) # 庄家第一张牌\n",
    "    player_points = np.arange(12,22)\n",
    "    for i in range(11, 22): # 玩家总牌点\n",
    "        for j in range(1, 11): # 庄家第一张牌 \n",
    "            s = j, i, useable_ace\n",
    "            s = str_key(s)\n",
    "            a = policy(A, s, Q, epsilon)\n",
    "            Z[i-11,j-1] = value_of(a)\n",
    "            #print(s, a)\n",
    "    \n",
    "    plt.imshow(Z, cmap=plt.cm.cool, interpolation=None, origin=\"lower\", extent=[0.5,11.5,10.5,21.5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "draw_value(player.Q, useable_ace = True, is_q_dict=True, A = player.A)\n",
    "draw_policy(epsilon_greedy_policy, player.A, player.Q, epsilon = 1e-10, useable_ace = True)\n",
    "draw_value(player.Q, useable_ace = False, is_q_dict=True, A = player.A)\n",
    "draw_policy(epsilon_greedy_policy, player.A, player.Q, epsilon = 1e-10, useable_ace = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10000/10000 [00:01<00:00, 7908.94it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "共玩了10000局，玩家赢4411局，和915局，输4674局，胜率：0.44,不输率:0.53\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "display = False\n",
    "arena.display = display\n",
    "player.display = display\n",
    "dealer.display = display\n",
    "arena.play_games(dealer,player,num=10000, show_statistic = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10/10 [00:00<00:00, 1836.39it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "========= 开始新一局 =========\n",
      "发了2张牌(['A', '7'])给玩家;玩家现在的牌:['A', '7']\n",
      "发了2张牌(['5', '3'])给庄家;庄家现在的牌:['5', '3']\n",
      "玩家选择:继续叫牌;发了1张牌(['2'])给玩家;玩家现在的牌:['A', '7', '2']\n",
      "玩家选择:停止叫牌;\n",
      "庄家选择:继续叫牌;发了1张牌(['9'])给庄家;庄家现在的牌:['5', '3', '9']\n",
      "庄家选择:停止叫牌;\n",
      "双方均了停止叫牌;\n",
      "玩家现在的牌:['A', '7', '2']\n",
      "庄家现在的牌:['5', '3', '9']\n",
      "玩家赢了!玩家20点,庄家17点\n",
      "========= 本局结束 ==========\n",
      "========= 开始新一局 =========\n",
      "发了2张牌(['4', '8'])给玩家;玩家现在的牌:['4', '8']\n",
      "发了2张牌(['7', 'Q'])给庄家;庄家现在的牌:['7', 'Q']\n",
      "玩家选择:继续叫牌;发了1张牌(['4'])给玩家;玩家现在的牌:['4', '8', '4']\n",
      "玩家选择:继续叫牌;发了1张牌(['10'])给玩家;玩家现在的牌:['4', '8', '4', '10']\n",
      "玩家选择:停止叫牌;玩家爆点26输了，得分:-1\n",
      "========= 本局结束 ==========\n",
      "========= 开始新一局 =========\n",
      "发了2张牌(['9', 'A'])给玩家;玩家现在的牌:['9', 'A']\n",
      "发了2张牌(['5', '7'])给庄家;庄家现在的牌:['5', '7']\n",
      "玩家选择:停止叫牌;\n",
      "庄家选择:继续叫牌;发了1张牌(['K'])给庄家;庄家现在的牌:['5', '7', 'K']\n",
      "庄家选择:停止叫牌;\n",
      "双方均了停止叫牌;\n",
      "玩家现在的牌:['9', 'A']\n",
      "庄家现在的牌:['5', '7', 'K']\n",
      "玩家赢了!玩家20点,庄家22点\n",
      "========= 本局结束 ==========\n",
      "========= 开始新一局 =========\n",
      "发了2张牌(['A', 'J'])给玩家;玩家现在的牌:['A', 'J']\n",
      "发了2张牌(['Q', 'Q'])给庄家;庄家现在的牌:['Q', 'Q']\n",
      "玩家选择:停止叫牌;\n",
      "庄家选择:停止叫牌;\n",
      "双方均了停止叫牌;\n",
      "玩家现在的牌:['A', 'J']\n",
      "庄家现在的牌:['Q', 'Q']\n",
      "玩家赢了!玩家21点,庄家20点\n",
      "========= 本局结束 ==========\n",
      "========= 开始新一局 =========\n",
      "发了2张牌(['9', '3'])给玩家;玩家现在的牌:['9', '3']\n",
      "发了2张牌(['2', '5'])给庄家;庄家现在的牌:['2', '5']\n",
      "玩家选择:继续叫牌;发了1张牌(['2'])给玩家;玩家现在的牌:['9', '3', '2']\n",
      "玩家选择:停止叫牌;\n",
      "庄家选择:继续叫牌;发了1张牌(['8'])给庄家;庄家现在的牌:['2', '5', '8']\n",
      "庄家选择:继续叫牌;发了1张牌(['A'])给庄家;庄家现在的牌:['2', '5', '8', 'A']\n",
      "庄家选择:继续叫牌;发了1张牌(['J'])给庄家;庄家现在的牌:['2', '5', '8', 'A', 'J']\n",
      "庄家选择:停止叫牌;\n",
      "双方均了停止叫牌;\n",
      "玩家现在的牌:['9', '3', '2']\n",
      "庄家现在的牌:['2', '5', '8', 'A', 'J']\n",
      "玩家赢了!玩家14点,庄家26点\n",
      "========= 本局结束 ==========\n",
      "========= 开始新一局 =========\n",
      "发了2张牌(['10', '10'])给玩家;玩家现在的牌:['10', '10']\n",
      "发了2张牌(['J', '7'])给庄家;庄家现在的牌:['J', '7']\n",
      "玩家选择:停止叫牌;\n",
      "庄家选择:停止叫牌;\n",
      "双方均了停止叫牌;\n",
      "玩家现在的牌:['10', '10']\n",
      "庄家现在的牌:['J', '7']\n",
      "玩家赢了!玩家20点,庄家17点\n",
      "========= 本局结束 ==========\n",
      "========= 开始新一局 =========\n",
      "发了2张牌(['10', '4'])给玩家;玩家现在的牌:['10', '4']\n",
      "\n",
      "发牌器没牌了，整理废牌，重新洗牌;一共整理了49张已用牌，重新放入发牌器\n",
      "发了2张牌(['6', '6'])给庄家;庄家现在的牌:['6', '6']\n",
      "玩家选择:停止叫牌;\n",
      "庄家选择:继续叫牌;发了1张牌(['9'])给庄家;庄家现在的牌:['6', '6', '9']\n",
      "庄家选择:停止叫牌;\n",
      "双方均了停止叫牌;\n",
      "玩家现在的牌:['10', '4']\n",
      "庄家现在的牌:['6', '6', '9']\n",
      "玩家输了!玩家14点,庄家21点\n",
      "========= 本局结束 ==========\n",
      "========= 开始新一局 =========\n",
      "发了2张牌(['6', 'A'])给玩家;玩家现在的牌:['6', 'A']\n",
      "发了2张牌(['K', '5'])给庄家;庄家现在的牌:['K', '5']\n",
      "玩家选择:继续叫牌;发了1张牌(['9'])给玩家;玩家现在的牌:['6', 'A', '9']\n",
      "玩家选择:继续叫牌;发了1张牌(['10'])给玩家;玩家现在的牌:['6', 'A', '9', '10']\n",
      "玩家选择:停止叫牌;玩家爆点26输了，得分:-1\n",
      "========= 本局结束 ==========\n",
      "========= 开始新一局 =========\n",
      "发了2张牌(['J', '3'])给玩家;玩家现在的牌:['J', '3']\n",
      "发了2张牌(['4', '7'])给庄家;庄家现在的牌:['4', '7']\n",
      "玩家选择:停止叫牌;\n",
      "庄家选择:继续叫牌;发了1张牌(['7'])给庄家;庄家现在的牌:['4', '7', '7']\n",
      "庄家选择:停止叫牌;\n",
      "双方均了停止叫牌;\n",
      "玩家现在的牌:['J', '3']\n",
      "庄家现在的牌:['4', '7', '7']\n",
      "玩家输了!玩家13点,庄家18点\n",
      "========= 本局结束 ==========\n",
      "========= 开始新一局 =========\n",
      "发了2张牌(['Q', '2'])给玩家;玩家现在的牌:['Q', '2']\n",
      "发了2张牌(['7', 'K'])给庄家;庄家现在的牌:['7', 'K']\n",
      "玩家选择:继续叫牌;发了1张牌(['J'])给玩家;玩家现在的牌:['Q', '2', 'J']\n",
      "玩家选择:停止叫牌;玩家爆点22输了，得分:-1\n",
      "========= 本局结束 ==========\n",
      "共玩了10局，玩家赢5局，和0局，输5局，胜率：0.50,不输率:0.50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "display = True\n",
    "arena.display = display\n",
    "player.display = display\n",
    "dealer.display = display\n",
    "arena.play_games(dealer,player,num=10, show_statistic = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
